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')
      }
    })
  })
})