manoon-headless/src/__tests__/unit/services/OrderNotificationService.test.ts

import { describe, it, expect, vi, beforeEach } from "vitest";
import { orderNotificationService } from "@/lib/services/OrderNotificationService";
import { sendEmailToCustomer, sendEmailToAdmin } from "@/lib/resend";
import { mockOrderConverted } from "../../fixtures/orders";

// Mock the resend module
vi.mock("@/lib/resend", () => ({
  sendEmailToCustomer: vi.fn().mockResolvedValue({ id: "test-email-id" }),
  sendEmailToAdmin: vi.fn().mockResolvedValue({ id: "test-email-id" }),
  ADMIN_EMAILS: ["me@hytham.me", "tamara@hytham.me"],
}));

describe("OrderNotificationService", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  describe("sendOrderConfirmation", () => {
    it("should send customer order confirmation in correct language (EN)", async () => {
      const order = { ...mockOrderConverted, languageCode: "EN" };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          to: "test@hytham.me",
          subject: "Order Confirmation #1524",
        })
      );
    });

    it("should send customer order confirmation in Serbian (SR)", async () => {
      const order = { ...mockOrderConverted, languageCode: "SR" };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          to: "test@hytham.me",
          subject: "Potvrda narudžbine #1524",
        })
      );
    });

    it("should send customer order confirmation in German (DE)", async () => {
      const order = { ...mockOrderConverted, languageCode: "DE" };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          to: "test@hytham.me",
          subject: "Bestellbestätigung #1524",
        })
      );
    });

    it("should send customer order confirmation in French (FR)", async () => {
      const order = { ...mockOrderConverted, languageCode: "FR" };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          to: "test@hytham.me",
          subject: "Confirmation de commande #1524",
        })
      );
    });

    it("should format price correctly", async () => {
      const order = {
        ...mockOrderConverted,
        total: {
          gross: {
            amount: 5479,
            currency: "RSD",
          },
        },
      };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          subject: "Order Confirmation #1524",
        })
      );
    });

    it("should handle missing variant name gracefully", async () => {
      const order = {
        ...mockOrderConverted,
        lines: [
          {
            ...mockOrderConverted.lines[0],
            variantName: undefined,
          },
        ],
      };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalled();
    });

    it("should include variant name when present", async () => {
      await orderNotificationService.sendOrderConfirmation(mockOrderConverted);

      expect(sendEmailToCustomer).toHaveBeenCalled();
    });
  });

  describe("sendOrderConfirmationToAdmin", () => {
    it("should send admin notification with order details", async () => {
      await orderNotificationService.sendOrderConfirmationToAdmin(mockOrderConverted);

      expect(sendEmailToAdmin).toHaveBeenCalledWith(
        expect.objectContaining({
          subject: expect.stringContaining("🎉 New Order #1524"),
          eventType: "ORDER_CONFIRMED",
          orderId: "T3JkZXI6MTIzNDU2Nzg=",
        })
      );
    });

    it("should always use English for admin emails", async () => {
      const order = { ...mockOrderConverted, languageCode: "SR" };

      await orderNotificationService.sendOrderConfirmationToAdmin(order);

      expect(sendEmailToAdmin).toHaveBeenCalledWith(
        expect.objectContaining({
          eventType: "ORDER_CONFIRMED",
        })
      );
    });

    it("should include all order details in admin email", async () => {
      await orderNotificationService.sendOrderConfirmationToAdmin(mockOrderConverted);

      expect(sendEmailToAdmin).toHaveBeenCalledWith(
        expect.objectContaining({
          subject: expect.stringContaining("🎉 New Order"),
          eventType: "ORDER_CONFIRMED",
        })
      );
    });
  });

  describe("sendOrderShipped", () => {
    it("should send shipping confirmation with tracking", async () => {
      await orderNotificationService.sendOrderShipped(
        mockOrderConverted,
        "TRK123",
        "https://track.com/TRK123"
      );

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          to: "test@hytham.me",
          subject: "Your Order #1524 Has Shipped!",
        })
      );
    });

    it("should handle missing tracking info", async () => {
      await orderNotificationService.sendOrderShipped(mockOrderConverted);

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          subject: "Your Order #1524 Has Shipped!",
        })
      );
    });
  });

  describe("sendOrderCancelled", () => {
    it("should send cancellation email with reason", async () => {
      await orderNotificationService.sendOrderCancelled(
        mockOrderConverted,
        "Out of stock"
      );

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          to: "test@hytham.me",
          subject: "Your Order #1524 Has Been Cancelled",
        })
      );
    });
  });

  describe("sendOrderPaid", () => {
    it("should send payment confirmation", async () => {
      await orderNotificationService.sendOrderPaid(mockOrderConverted);

      expect(sendEmailToCustomer).toHaveBeenCalledWith(
        expect.objectContaining({
          to: "test@hytham.me",
          subject: "Payment Received for Order #1524!",
        })
      );
    });
  });

  describe("formatPrice", () => {
    it("should format prices correctly for RSD", () => {
      // This is tested indirectly through the email calls above
      // The formatPrice function is in utils.ts
    });
  });

  describe("edge cases", () => {
    it("should handle orders with user name", async () => {
      const order = {
        ...mockOrderConverted,
        user: { firstName: "John", lastName: "Doe" },
      };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalled();
    });

    it("should handle orders without user object", async () => {
      const order = {
        ...mockOrderConverted,
        user: undefined,
      };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalled();
    });

    it("should handle orders with incomplete address", async () => {
      const order = {
        ...mockOrderConverted,
        shippingAddress: {
          firstName: "Test",
          lastName: "Customer",
          city: "Belgrade",
        },
      };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalled();
    });

    it("should handle orders with missing shipping address", async () => {
      const order = {
        ...mockOrderConverted,
        shippingAddress: undefined,
      };

      await orderNotificationService.sendOrderConfirmation(order);

      expect(sendEmailToCustomer).toHaveBeenCalled();
    });
  });
});