gridpilot.gg/tests/e2e/website/website-pages.test.ts

import { test, expect } from '@playwright/test';
import { WebsiteRouteManager } from '../../shared/website/WebsiteRouteManager';
import { WebsiteAuthManager } from '../../shared/website/WebsiteAuthManager';
import { ConsoleErrorCapture } from '../../shared/website/ConsoleErrorCapture';

const WEBSITE_BASE_URL = process.env.PLAYWRIGHT_BASE_URL || 'http://localhost:3000';

test.describe('Website Pages - TypeORM Integration', () => {
  let routeManager: WebsiteRouteManager;

  test.beforeEach(() => {
    routeManager = new WebsiteRouteManager();
  });

  test('website loads and connects to API', async ({ page }) => {
    // Test that the website loads
    const response = await page.goto(WEBSITE_BASE_URL);
    expect(response?.ok()).toBe(true);
    
    // Check that the page renders (body is visible)
    await expect(page.locator('body')).toBeVisible();
  });

  test('all routes from RouteConfig are discoverable', async () => {
    expect(() => routeManager.getWebsiteRouteInventory()).not.toThrow();
  });

  test('public routes are accessible without authentication', async ({ page }) => {
    const routes = routeManager.getWebsiteRouteInventory();
    const publicRoutes = routes.filter(r => r.access === 'public').slice(0, 5);

    for (const route of publicRoutes) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);
      const response = await page.goto(`${WEBSITE_BASE_URL}${path}`);
      
      // Should load successfully or show 404 page
      expect(response?.ok() || response?.status() === 404).toBeTruthy();
    }
  });

  test('protected routes redirect unauthenticated users to login', async ({ page }) => {
    const routes = routeManager.getWebsiteRouteInventory();
    const protectedRoutes = routes.filter(r => r.access !== 'public').slice(0, 3);

    for (const route of protectedRoutes) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);
      await page.goto(`${WEBSITE_BASE_URL}${path}`);
      
      const currentUrl = new URL(page.url());
      expect(currentUrl.pathname).toBe('/auth/login');
      expect(currentUrl.searchParams.get('returnTo')).toBe(path);
    }
  });

  test('admin routes require admin role', async ({ browser, request }) => {
    const routes = routeManager.getWebsiteRouteInventory();
    const adminRoutes = routes.filter(r => r.access === 'admin').slice(0, 2);

    for (const route of adminRoutes) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);

      // Regular auth user should be blocked
      {
        const auth = await WebsiteAuthManager.createAuthContext(browser, request, 'auth');
        await auth.page.goto(`${WEBSITE_BASE_URL}${path}`);
        expect(auth.page.url().includes('login')).toBeTruthy();
        await auth.context.close();
      }

      // Admin user should have access
      {
        const admin = await WebsiteAuthManager.createAuthContext(browser, request, 'admin');
        await admin.page.goto(`${WEBSITE_BASE_URL}${path}`);
        expect(admin.page.url().includes(path)).toBeTruthy();
        await admin.context.close();
      }
    }
  });

  test('sponsor routes require sponsor role', async ({ browser, request }) => {
    const routes = routeManager.getWebsiteRouteInventory();
    const sponsorRoutes = routes.filter(r => r.access === 'sponsor').slice(0, 2);

    for (const route of sponsorRoutes) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);

      // Regular auth user should be blocked
      {
        const auth = await WebsiteAuthManager.createAuthContext(browser, request, 'auth');
        await auth.page.goto(`${WEBSITE_BASE_URL}${path}`);
        const finalUrl = auth.page.url();
        console.log(`[DEBUG] Final URL: ${finalUrl}`);
        console.log(`[DEBUG] Includes 'login': ${finalUrl.includes('login')}`);
        expect(finalUrl.includes('login')).toBeTruthy();
        await auth.context.close();
      }

      // Sponsor user should have access
      {
        const sponsor = await WebsiteAuthManager.createAuthContext(browser, request, 'sponsor');
        await sponsor.page.goto(`${WEBSITE_BASE_URL}${path}`);
        expect(sponsor.page.url().includes(path)).toBeTruthy();
        await sponsor.context.close();
      }
    }
  });

  test('auth routes redirect authenticated users away', async ({ browser, request }) => {
    const routes = routeManager.getWebsiteRouteInventory();
    const authRoutes = routes.filter(r => r.access === 'auth').slice(0, 2);

    for (const route of authRoutes) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);

      const auth = await WebsiteAuthManager.createAuthContext(browser, request, 'auth');
      await auth.page.goto(`${WEBSITE_BASE_URL}${path}`);

      // Should redirect to dashboard or stay on the page
      const currentUrl = auth.page.url();
      expect(currentUrl.includes('dashboard') || currentUrl.includes(path)).toBeTruthy();

      await auth.context.close();
    }
  });

  test('parameterized routes handle edge cases', async ({ page }) => {
    const edgeCases = routeManager.getParamEdgeCases();

    for (const route of edgeCases) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);
      const response = await page.goto(`${WEBSITE_BASE_URL}${path}`);
      
      if (route.allowNotFound) {
        expect(response?.status() === 404 || response?.status() === 500).toBeTruthy();
      }
    }
  });

  test('no console or page errors on critical routes', async ({ page }) => {
    const faultRoutes = routeManager.getFaultInjectionRoutes();

    for (const route of faultRoutes) {
      const capture = new ConsoleErrorCapture(page);
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);
      
      await page.goto(`${WEBSITE_BASE_URL}${path}`);
      await page.waitForTimeout(500);

      const errors = capture.getErrors();
      expect(errors.length).toBe(0);
    }
  });

  test('TypeORM session persistence across routes', async ({ page }) => {
    const routes = routeManager.getWebsiteRouteInventory();
    const testRoutes = routes.filter(r => r.access === 'public').slice(0, 5);

    for (const route of testRoutes) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);
      const response = await page.goto(`${WEBSITE_BASE_URL}${path}`);
      
      expect(response?.ok() || response?.status() === 404).toBeTruthy();
    }
  });

  test('auth drift scenarios', async ({ page }) => {
    const driftRoutes = routeManager.getAuthDriftRoutes();

    for (const route of driftRoutes) {
      const path = routeManager.resolvePathTemplate(route.pathTemplate, route.params);
      
      // Try accessing protected route without auth
      await page.goto(`${WEBSITE_BASE_URL}${path}`);
      const currentUrl = page.url();
      
      expect(currentUrl.includes('login') || currentUrl.includes('auth')).toBeTruthy();
    }
  });

  test('handles invalid routes gracefully', async ({ page }) => {
    const invalidRoutes = [
      '/invalid-route',
      '/leagues/invalid-id',
      '/drivers/invalid-id',
    ];

    for (const route of invalidRoutes) {
      const response = await page.goto(`${WEBSITE_BASE_URL}${route}`);
      
      const status = response?.status();
      const url = page.url();
      
      expect([200, 404].includes(status ?? 0) || url.includes('/auth/login')).toBe(true);
    }
  });
});