@mohasinac/appkit 3.8.1 → 3.9.0

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

@@ -1,148 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-const { mockSendNotification, mockRtdbPush, mockDecryptPii, } = vi.hoisted(() => ({
-    mockSendNotification: vi.fn().mockResolvedValue(undefined),
-    mockRtdbPush: vi.fn().mockResolvedValue(undefined),
-    mockDecryptPii: vi.fn((v) => v),
-}));
-vi.mock("../../../../../features/admin/actions/notification-actions", () => ({
-    sendNotification: mockSendNotification,
-}));
-vi.mock("../../../../../providers/db-firebase", () => ({
-    getAdminRealtimeDb: vi.fn(() => ({
-        ref: vi.fn(() => ({ push: mockRtdbPush })),
-    })),
-}));
-vi.mock("../../../../../security/index", () => ({
-    decryptPii: mockDecryptPii,
-}));
-vi.mock("../../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { handleOrderStatusChange } from "../onOrderStatusChange";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeCtx() {
-    return {
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    };
-}
-function makeInput(beforeStatus, afterStatus, extraAfter = {}) {
-    return {
-        orderId: "order-1",
-        before: { status: beforeStatus },
-        after: {
-            status: afterStatus,
-            userId: "user-ravi",
-            userEmail: "ravi@example.com",
-            productTitle: "Pokemon Charizard",
-            trackingNumber: "TRK123",
-            ...extraAfter,
-        },
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockSendNotification.mockResolvedValue(undefined);
-    mockRtdbPush.mockResolvedValue(undefined);
-    mockDecryptPii.mockImplementation((v) => v);
-});
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe("handleOrderStatusChange — early exits", () => {
-    it("returns immediately when before is null", async () => {
-        const ctx = makeCtx();
-        await handleOrderStatusChange({ orderId: "o1", before: null, after: null }, ctx);
-        expect(mockSendNotification).not.toHaveBeenCalled();
-    });
-    it("returns immediately when after is null", async () => {
-        const ctx = makeCtx();
-        await handleOrderStatusChange({ orderId: "o1", before: { status: "pending" }, after: null }, ctx);
-        expect(mockSendNotification).not.toHaveBeenCalled();
-    });
-    it("returns when status has not changed", async () => {
-        const ctx = makeCtx();
-        await handleOrderStatusChange(makeInput("confirmed", "confirmed"), ctx);
-        expect(mockSendNotification).not.toHaveBeenCalled();
-    });
-    it("logs and returns when new status has no handler config", async () => {
-        const ctx = makeCtx();
-        await handleOrderStatusChange(makeInput("pending", "returned"), ctx);
-        expect(mockSendNotification).not.toHaveBeenCalled();
-        expect(ctx.logger.info).toHaveBeenCalledWith(expect.stringMatching(/No handler for status transition/i), expect.any(Object));
-    });
-});
-describe("handleOrderStatusChange — confirmed", () => {
-    it("sends order_confirmed notification to buyer", async () => {
-        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
-        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-ravi", type: "order_confirmed" }));
-    });
-    it("includes decrypted userEmail in notification payload", async () => {
-        mockDecryptPii.mockReturnValue("decrypted@example.com");
-        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
-        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userEmail: "decrypted@example.com" }));
-    });
-    it("pushes to RTDB for real-time notification", async () => {
-        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
-        expect(mockRtdbPush).toHaveBeenCalledWith(expect.objectContaining({ type: "order_confirmed" }));
-    });
-});
-describe("handleOrderStatusChange — shipped", () => {
-    it("sends order_shipped notification with high priority", async () => {
-        await handleOrderStatusChange(makeInput("confirmed", "shipped"), makeCtx());
-        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ type: "order_shipped", priority: "high" }));
-    });
-    it("notification message includes tracking number", async () => {
-        await handleOrderStatusChange(makeInput("confirmed", "shipped", { trackingNumber: "AWB123" }), makeCtx());
-        const notifCall = mockSendNotification.mock.calls[0][0];
-        expect(notifCall.message).toMatch(/AWB123/);
-    });
-});
-describe("handleOrderStatusChange — delivered", () => {
-    it("sends order_delivered notification", async () => {
-        await handleOrderStatusChange(makeInput("shipped", "delivered"), makeCtx());
-        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ type: "order_delivered" }));
-    });
-    it("notification relatedId = orderId, relatedType = 'order'", async () => {
-        await handleOrderStatusChange(makeInput("shipped", "delivered"), makeCtx());
-        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ relatedId: "order-1", relatedType: "order" }));
-    });
-});
-describe("handleOrderStatusChange — cancelled", () => {
-    it("sends order_cancelled notification", async () => {
-        await handleOrderStatusChange(makeInput("pending", "cancelled"), makeCtx());
-        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ type: "order_cancelled" }));
-    });
-    it("cancelled message mentions the product title", async () => {
-        await handleOrderStatusChange(makeInput("pending", "cancelled", { productTitle: "Hot Wheels Redline" }), makeCtx());
-        const notifCall = mockSendNotification.mock.calls[0][0];
-        expect(notifCall.message).toMatch(/Hot Wheels Redline/);
-    });
-});
-describe("handleOrderStatusChange — RTDB failure is non-fatal", () => {
-    it("RTDB push failure → logs but does NOT re-throw", async () => {
-        mockRtdbPush.mockRejectedValue(new Error("RTDB down"));
-        const ctx = makeCtx();
-        await expect(handleOrderStatusChange(makeInput("pending", "confirmed"), ctx)).resolves.toBeUndefined();
-        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/Realtime DB/i), expect.any(Error));
-    });
-    it("Firestore notification still sent even when RTDB fails", async () => {
-        mockRtdbPush.mockRejectedValue(new Error("RTDB down"));
-        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
-        expect(mockSendNotification).toHaveBeenCalled();
-    });
-});
-describe("handleOrderStatusChange — error propagation", () => {
-    it("sendNotification failure → re-throws", async () => {
-        mockSendNotification.mockRejectedValue(new Error("Notification service down"));
-        await expect(handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx())).rejects.toThrow("Notification service down");
-    });
-    it("logs error context before re-throwing", async () => {
-        mockSendNotification.mockRejectedValue(new Error("Notification service down"));
-        const ctx = makeCtx();
-        try {
-            await handleOrderStatusChange(makeInput("pending", "confirmed"), ctx);
-        }
-        catch {
-            // expected
-        }
-        expect(ctx.logger.error).toHaveBeenCalledWith(expect.any(String), expect.any(Error), expect.objectContaining({ orderId: "order-1" }));
-    });
-});

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

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

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

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-// onProductStockChange uses ctx.db directly, no repository imports needed.
-vi.mock("../../../../../errors/normalize", () => ({
-    normalizeError: vi.fn(),
-}));
-import { handleProductStockChange, isAvailable, syncBundlesForProduct, } from "../onProductStockChange";
-import { PRODUCT_FIELDS } from "../../../../../constants/field-names";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeCtx(dbQuery) {
-    const mockQuery = dbQuery ?? vi.fn().mockReturnThis();
-    const queryChain = { where: vi.fn().mockReturnThis(), get: vi.fn() };
-    return {
-        db: {
-            collection: vi.fn().mockReturnValue(queryChain),
-        },
-        queryChain,
-        now: new Date(),
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    };
-}
-const PUBLISHED = PRODUCT_FIELDS.STATUS_VALUES.PUBLISHED;
-// ── isAvailable (pure function) ───────────────────────────────────────────────
-describe("isAvailable — pure function", () => {
-    it("null doc → false", () => {
-        expect(isAvailable(null)).toBe(false);
-    });
-    it("isSold=true → false", () => {
-        expect(isAvailable({ isSold: true, availableQuantity: 1, status: PUBLISHED })).toBe(false);
-    });
-    it("availableQuantity=0 → false", () => {
-        expect(isAvailable({ isSold: false, availableQuantity: 0, status: PUBLISHED })).toBe(false);
-    });
-    it("status != published → false", () => {
-        expect(isAvailable({ isSold: false, availableQuantity: 5, status: "draft" })).toBe(false);
-    });
-    it("status=published, qty>0, not sold → true", () => {
-        expect(isAvailable({ isSold: false, availableQuantity: 1, status: PUBLISHED })).toBe(true);
-    });
-    it("qty undefined (no quantity field) → true (quantity not tracked = always available)", () => {
-        // Intentional design: the check is `typeof qty === "number" && qty <= 0`.
-        // If qty is undefined, the guard is skipped → published product is available.
-        expect(isAvailable({ isSold: false, availableQuantity: undefined, status: PUBLISHED })).toBe(true);
-    });
-});
-// ── handleProductStockChange ──────────────────────────────────────────────────
-const INPUT_BASE = {
-    productId: "product-charizard",
-    isDelete: false,
-};
-function makeAvailableSnap() {
-    return { isSold: false, availableQuantity: 1, status: PUBLISHED };
-}
-function makeUnavailableSnap() {
-    return { isSold: false, availableQuantity: 0, status: PUBLISHED };
-}
-describe("handleProductStockChange — early exit: no state flip", () => {
-    it("skips when available → available (no flip)", async () => {
-        const ctx = makeCtx();
-        await handleProductStockChange({
-            ...INPUT_BASE,
-            before: makeAvailableSnap(),
-            after: makeAvailableSnap(),
-        }, ctx);
-        expect(ctx.db.collection).not.toHaveBeenCalled();
-    });
-    it("skips when unavailable → unavailable (no flip)", async () => {
-        const ctx = makeCtx();
-        await handleProductStockChange({
-            ...INPUT_BASE,
-            before: makeUnavailableSnap(),
-            after: makeUnavailableSnap(),
-        }, ctx);
-        expect(ctx.db.collection).not.toHaveBeenCalled();
-    });
-    it("processes when isDelete=true even if state appears unchanged", async () => {
-        const ctx = makeCtx();
-        ctx.db.collection = vi.fn().mockReturnValue({
-            where: vi.fn().mockReturnThis(),
-            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
-        });
-        await handleProductStockChange({
-            ...INPUT_BASE,
-            isDelete: true,
-            before: makeAvailableSnap(),
-            after: makeAvailableSnap(),
-        }, ctx);
-        expect(ctx.db.collection).toHaveBeenCalled();
-    });
-});
-describe("handleProductStockChange — state flip triggers sync", () => {
-    it("available → unavailable triggers sync", async () => {
-        const ctx = makeCtx();
-        ctx.db.collection = vi.fn().mockReturnValue({
-            where: vi.fn().mockReturnThis(),
-            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
-        });
-        await handleProductStockChange({
-            ...INPUT_BASE,
-            before: makeAvailableSnap(),
-            after: makeUnavailableSnap(),
-        }, ctx);
-        expect(ctx.db.collection).toHaveBeenCalled();
-    });
-    it("unavailable → available triggers sync", async () => {
-        const ctx = makeCtx();
-        ctx.db.collection = vi.fn().mockReturnValue({
-            where: vi.fn().mockReturnThis(),
-            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
-        });
-        await handleProductStockChange({
-            ...INPUT_BASE,
-            before: makeUnavailableSnap(),
-            after: makeAvailableSnap(),
-        }, ctx);
-        expect(ctx.db.collection).toHaveBeenCalled();
-    });
-    it("logs synced bundles and groups count", async () => {
-        const ctx = makeCtx();
-        ctx.db.collection = vi.fn().mockReturnValue({
-            where: vi.fn().mockReturnThis(),
-            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
-        });
-        await handleProductStockChange({
-            ...INPUT_BASE,
-            before: makeAvailableSnap(),
-            after: makeUnavailableSnap(),
-        }, ctx);
-        expect(ctx.logger.info).toHaveBeenCalledWith("onProductStockChange synced", expect.objectContaining({ productId: "product-charizard" }));
-    });
-    it("sync failure is non-fatal — logs error but does not throw", async () => {
-        const ctx = makeCtx();
-        ctx.db.collection = vi.fn().mockImplementation(() => {
-            throw new Error("Firestore unavailable");
-        });
-        await expect(handleProductStockChange({
-            ...INPUT_BASE,
-            before: makeAvailableSnap(),
-            after: makeUnavailableSnap(),
-        }, ctx)).resolves.toBeUndefined();
-        expect(ctx.logger.error).toHaveBeenCalled();
-    });
-});
-describe("syncBundlesForProduct — bundle recompute", () => {
-    it("does nothing when no bundles reference the product", async () => {
-        const ctx = makeCtx();
-        const mockQuery = { where: vi.fn().mockReturnThis(), get: vi.fn().mockResolvedValue({ docs: [], size: 0 }) };
-        ctx.db.collection = vi.fn().mockReturnValue(mockQuery);
-        const updated = await syncBundlesForProduct("product-x", ctx);
-        expect(updated).toBe(0);
-    });
-    it("updates bundle when stockStatus changes", async () => {
-        // Bundle has 1 product: "product-x" (now unavailable)
-        const bundleRef = { update: vi.fn().mockResolvedValue(undefined) };
-        const bundleDoc = {
-            ref: bundleRef,
-            data: () => ({
-                bundleProductIds: ["product-x"],
-                bundleStockStatus: "in_stock", // currently in_stock...
-            }),
-        };
-        const memberSnap = {
-            docs: [{ data: () => ({ isSold: false, availableQuantity: 0, status: PUBLISHED }) }],
-            size: 1,
-        };
-        const ctx = makeCtx();
-        let callIdx = 0;
-        ctx.db.collection = vi.fn().mockReturnValue({
-            where: vi.fn().mockReturnThis(),
-            get: vi.fn().mockImplementation(async () => {
-                callIdx++;
-                // First call = bundles query; subsequent calls = member product queries
-                if (callIdx === 1)
-                    return { docs: [bundleDoc], size: 1 };
-                return memberSnap;
-            }),
-        });
-        const updated = await syncBundlesForProduct("product-x", ctx);
-        expect(updated).toBe(1);
-        expect(bundleRef.update).toHaveBeenCalledWith(expect.objectContaining({ bundleStockStatus: "out_of_stock" }));
-    });
-    it("does NOT update bundle when stockStatus has not changed", async () => {
-        const bundleRef = { update: vi.fn().mockResolvedValue(undefined) };
-        const bundleDoc = {
-            ref: bundleRef,
-            data: () => ({
-                bundleProductIds: ["product-x"],
-                bundleStockStatus: "in_stock", // already in_stock
-            }),
-        };
-        // Member is available → status stays in_stock → no update needed
-        const memberSnap = {
-            docs: [{ data: () => ({ isSold: false, availableQuantity: 5, status: PUBLISHED }) }],
-            size: 1,
-        };
-        const ctx = makeCtx();
-        let callIdx = 0;
-        ctx.db.collection = vi.fn().mockReturnValue({
-            where: vi.fn().mockReturnThis(),
-            get: vi.fn().mockImplementation(async () => {
-                callIdx++;
-                if (callIdx === 1)
-                    return { docs: [bundleDoc], size: 1 };
-                return memberSnap;
-            }),
-        });
-        const updated = await syncBundlesForProduct("product-x", ctx);
-        expect(updated).toBe(0);
-        expect(bundleRef.update).not.toHaveBeenCalled();
-    });
-});

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

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

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

@@ -1,190 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-const { mockGetRatingAggregate, mockGetRatingAggregateByStore, mockProductUpdate, mockUpdateReviewStats, } = vi.hoisted(() => ({
-    mockGetRatingAggregate: vi.fn(),
-    mockGetRatingAggregateByStore: vi.fn(),
-    mockProductUpdate: vi.fn().mockResolvedValue(undefined),
-    mockUpdateReviewStats: vi.fn().mockResolvedValue(undefined),
-}));
-vi.mock("../../../../../repositories", () => ({
-    reviewRepository: {
-        getApprovedRatingAggregate: mockGetRatingAggregate,
-        getApprovedRatingAggregateByStore: mockGetRatingAggregateByStore,
-    },
-    storeRepository: {
-        updateReviewStats: mockUpdateReviewStats,
-    },
-}));
-vi.mock("../../../../../features/reviews/schemas/firestore", () => ({
-    ReviewStatusValues: {
-        APPROVED: "approved",
-        PENDING: "pending",
-        REJECTED: "rejected",
-    },
-}));
-vi.mock("../../../../../features/products/schemas/firestore", () => ({
-    PRODUCT_COLLECTION: "products",
-}));
-import { handleReviewWrite } from "../onReviewWrite";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeCtx() {
-    return {
-        db: {
-            collection: vi.fn().mockReturnValue({
-                doc: vi.fn().mockReturnValue({
-                    update: mockProductUpdate,
-                }),
-            }),
-        },
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    };
-}
-function makeReviewData(overrides = {}) {
-    return {
-        productId: "product-charizard",
-        storeId: "store-A",
-        buyerId: "user-ravi",
-        rating: 5,
-        status: "approved",
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockProductUpdate.mockResolvedValue(undefined);
-    mockUpdateReviewStats.mockResolvedValue(undefined);
-    mockGetRatingAggregate.mockResolvedValue({ count: 10, avgRating: 4.5 });
-    mockGetRatingAggregateByStore.mockResolvedValue({ count: 5, avgRating: 4.2 });
-});
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe("handleReviewWrite — early exits", () => {
-    it("skips if neither before nor after is approved", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "pending" }),
-            after: makeReviewData({ status: "rejected" }),
-        }, ctx);
-        expect(mockGetRatingAggregate).not.toHaveBeenCalled();
-    });
-    it("skips if both before and after are non-approved status", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "rejected" }),
-            after: makeReviewData({ status: "pending" }),
-        }, ctx);
-        expect(mockProductUpdate).not.toHaveBeenCalled();
-    });
-    it("skips if no data (both before and after are null)", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({ reviewId: "r1", before: null, after: null }, ctx);
-        expect(mockGetRatingAggregate).not.toHaveBeenCalled();
-    });
-    it("logs and skips if review has no productId", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: null,
-            after: makeReviewData({ status: "approved", productId: undefined }),
-        }, ctx);
-        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/no productId/i), null, expect.any(Object));
-        expect(mockGetRatingAggregate).not.toHaveBeenCalled();
-    });
-});
-describe("handleReviewWrite — review approved (new approval)", () => {
-    it("recalculates rating aggregate for the product", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "pending" }),
-            after: makeReviewData({ status: "approved" }),
-        }, ctx);
-        expect(mockGetRatingAggregate).toHaveBeenCalledWith("product-charizard");
-    });
-    it("updates product avgRating and reviewCount", async () => {
-        mockGetRatingAggregate.mockResolvedValue({ count: 7, avgRating: 4.2 });
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "pending" }),
-            after: makeReviewData({ status: "approved" }),
-        }, ctx);
-        expect(mockProductUpdate).toHaveBeenCalledWith(expect.objectContaining({ avgRating: 4.2, reviewCount: 7 }));
-    });
-    it("updates store review stats when storeId is present", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "pending" }),
-            after: makeReviewData({ status: "approved", storeId: "store-A" }),
-        }, ctx);
-        expect(mockGetRatingAggregateByStore).toHaveBeenCalledWith("store-A");
-        expect(mockUpdateReviewStats).toHaveBeenCalledWith("store-A", 5, 4.2);
-    });
-    it("skips store stats update when storeId is absent", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "pending" }),
-            after: makeReviewData({ status: "approved", storeId: undefined }),
-        }, ctx);
-        expect(mockGetRatingAggregateByStore).not.toHaveBeenCalled();
-        expect(mockUpdateReviewStats).not.toHaveBeenCalled();
-    });
-});
-describe("handleReviewWrite — review rejected (was approved)", () => {
-    it("recalculates rating when a review transitions from approved to rejected", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "approved" }),
-            after: makeReviewData({ status: "rejected" }),
-        }, ctx);
-        expect(mockGetRatingAggregate).toHaveBeenCalled();
-        expect(mockProductUpdate).toHaveBeenCalled();
-    });
-    it("uses afterData for productId when available", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "approved", productId: "old-product" }),
-            after: makeReviewData({ status: "rejected", productId: "product-charizard" }),
-        }, ctx);
-        expect(mockGetRatingAggregate).toHaveBeenCalledWith("product-charizard");
-    });
-    it("falls back to beforeData for productId when after is null (delete)", async () => {
-        const ctx = makeCtx();
-        await handleReviewWrite({
-            reviewId: "r1",
-            before: makeReviewData({ status: "approved", productId: "product-abc" }),
-            after: null,
-        }, ctx);
-        expect(mockGetRatingAggregate).toHaveBeenCalledWith("product-abc");
-    });
-});
-describe("handleReviewWrite — error propagation", () => {
-    it("aggregate calculation failure → re-throws", async () => {
-        mockGetRatingAggregate.mockRejectedValue(new Error("Firestore error"));
-        const ctx = makeCtx();
-        await expect(handleReviewWrite({
-            reviewId: "r1",
-            before: null,
-            after: makeReviewData({ status: "approved" }),
-        }, ctx)).rejects.toThrow("Firestore error");
-    });
-    it("logs error before re-throwing", async () => {
-        mockGetRatingAggregate.mockRejectedValue(new Error("Firestore error"));
-        const ctx = makeCtx();
-        try {
-            await handleReviewWrite({
-                reviewId: "r1",
-                before: null,
-                after: makeReviewData({ status: "approved" }),
-            }, ctx);
-        }
-        catch {
-            // expected
-        }
-        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/rating stats/i), expect.any(Error), expect.any(Object));
-    });
-});

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

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