livedash-node/tests/unit/platform-dashboard.test.tsx

import { describe, it, expect, vi, beforeEach } from "vitest";

// Mock modules before imports
vi.mock("next-auth/react", () => ({
  useSession: vi.fn(),
  SessionProvider: ({ children }: { children: React.ReactNode }) => children,
}));

vi.mock("next/navigation", () => ({
  redirect: vi.fn(),
  useRouter: vi.fn(() => ({
    push: vi.fn(),
    refresh: vi.fn(),
  })),
}));

describe("Platform Dashboard", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    global.fetch = vi.fn();
  });

  describe("Authentication", () => {
    it("should require platform user authentication", () => {
      // Test that the dashboard checks for platform user authentication
      const mockSession = {
        user: {
          email: "admin@notso.ai",
          isPlatformUser: true,
          platformRole: "SUPER_ADMIN",
        },
        expires: new Date().toISOString(),
      };

      expect(mockSession.user.isPlatformUser).toBe(true);
      expect(mockSession.user.platformRole).toBeTruthy();
    });

    it("should not allow regular users", () => {
      const mockSession = {
        user: {
          email: "regular@user.com",
          isPlatformUser: false,
        },
        expires: new Date().toISOString(),
      };

      expect(mockSession.user.isPlatformUser).toBe(false);
    });
  });

  describe("Dashboard Data Structure", () => {
    it("should have correct dashboard data structure", () => {
      const expectedDashboardData = {
        companies: [
          {
            id: "1",
            name: "Test Company",
            status: "ACTIVE",
            createdAt: "2024-01-01T00:00:00Z",
            _count: { users: 5 },
          },
        ],
        totalCompanies: 1,
        totalUsers: 5,
        totalSessions: 100,
      };

      expect(expectedDashboardData).toHaveProperty("companies");
      expect(expectedDashboardData).toHaveProperty("totalCompanies");
      expect(expectedDashboardData).toHaveProperty("totalUsers");
      expect(expectedDashboardData).toHaveProperty("totalSessions");
      expect(Array.isArray(expectedDashboardData.companies)).toBe(true);
    });

    it("should support different company statuses", () => {
      const statuses = ["ACTIVE", "SUSPENDED", "TRIAL"];

      statuses.forEach((status) => {
        const company = {
          id: "1",
          name: "Test Company",
          status,
          createdAt: new Date().toISOString(),
          _count: { users: 1 },
        };

        expect(["ACTIVE", "SUSPENDED", "TRIAL"]).toContain(company.status);
      });
    });
  });

  describe("Platform Roles", () => {
    it("should support all platform roles", () => {
      const roles = [
        { role: "SUPER_ADMIN", canEdit: true },
        { role: "ADMIN", canEdit: true },
        { role: "SUPPORT", canEdit: false },
      ];

      roles.forEach(({ role, canEdit }) => {
        const user = {
          email: `${role.toLowerCase()}@notso.ai`,
          isPlatformUser: true,
          platformRole: role,
        };

        expect(user.platformRole).toBe(role);
        if (role === "SUPER_ADMIN" || role === "ADMIN") {
          expect(canEdit).toBe(true);
        } else {
          expect(canEdit).toBe(false);
        }
      });
    });
  });

  describe("API Integration", () => {
    it("should fetch dashboard data from correct endpoint", async () => {
      const mockFetch = vi.fn().mockResolvedValue({
        ok: true,
        json: async () => ({
          companies: [],
          totalCompanies: 0,
          totalUsers: 0,
          totalSessions: 0,
        }),
      });

      global.fetch = mockFetch;

      // Simulate API call
      await fetch("/api/platform/companies");

      expect(mockFetch).toHaveBeenCalledWith("/api/platform/companies");
    });

    it("should handle API errors", async () => {
      const mockFetch = vi.fn().mockRejectedValue(new Error("Network error"));
      global.fetch = mockFetch;

      try {
        await fetch("/api/platform/companies");
      } catch (error) {
        expect(error).toBeInstanceOf(Error);
        expect((error as Error).message).toBe("Network error");
      }
    });
  });
});