universe/e2e/60-surfaces.spec.ts

import { test, expect, APIRequestContext } from '@playwright/test'
import { env } from './env'
import { NOT_SERVED, ROUTE_COUNT, SURFACES } from './routes'
import { exchangeBase, expectRendered, httpStatus, renderRoute, snap } from './helpers'

// ---------------------------------------------------------------------------
// EVERY PAGE OF EVERY PRODUCT, anonymously — the coverage floor
// ---------------------------------------------------------------------------
// Before this file the suite tested 8 of lux.cloud's 82 pages, 7 of the
// explorer's, 0 of Safe's 31, 1 of MPC's 15, 0 of the admin surface, and 0 of
// the exchange's 22 (all skipped behind an unreachable vanity host). Whole
// shipped products had no test that would notice if they stopped rendering.
//
// The routes live in e2e/routes.ts as DATA, so this file is one loop, and
// adding a page to a product is one line there rather than a new spec here.
//
// WHAT IT ASSERTS, and why it is not a status-code sweep: SEVEN of the nine
// origins answer 200 for a path that does not exist (measured with a /zzz-bogus
// control against each — see e2e/routes.ts). A green status sweep across them
// would be worth exactly nothing. So every route is opened in a real browser at
// the project's viewport and has to have PAINTED: real text into a non-empty
// root, and not the app's own error boundary. Two separate assertions, because
// a crash screen sails through a length check — exchange /pool serves HTTP 200
// with 553 characters, all of which say "Something went wrong".
//
// Between them they catch both live failure shapes: the white screen behind a
// 200 (exchange /vote — 0 chars, 0 root children, every load) and the crash
// screen behind a 200 (exchange /pool, /positions, /bridge, /teleport).
//
// Protected routes are asserted as protected. The MPC console's 13 signed-in
// screens — including /bridge/fees, the owner's "manage bridge fees" — must
// bounce an anonymous browser to the login screen. Serving them would be the
// finding, so the redirect IS the pass.
//
// Read-only throughout. It opens pages and looks at them. No form is submitted,
// nothing is signed, nothing is broadcast.

test.describe.configure({ mode: 'parallel' })

console.log(`  route registry: ${ROUTE_COUNT} declared pages across ${SURFACES.length} surfaces `
  + `— LUX_ENV=${env.name}`)

for (const s of SURFACES) {
  test.describe(`${s.label}`, () => {
    // The exchange is reached through whichever of its two hostnames answers
    // from this network — resolved once, in helpers, and logged.
    async function base(request: APIRequestContext): Promise<string> {
      return s.id === 'exchange' ? await exchangeBase(request) : s.base
    }

    for (const route of s.routes) {
      const name = route === '/' ? 'home' : route.replace(/^\//, '').replace(/\//g, '-')

      if (s.auth === 'login-redirect') {
        test(`${route} is protected`, async ({ page, request }) => {
          const url = (await base(request)) + route
          const r = await renderRoute(page, url)
          const landed = new URL(r.url)
          console.log(`  ${route} → ${landed.pathname} (HTTP ${r.status}, ${r.textLen} chars)`)

          // POSITIVE signal: the browser ended up on a sign-in screen. Either
          // the URL is the login path, or the page is showing a sign-in form.
          const onLogin = /login|signin|sign-in|auth/i.test(landed.pathname + landed.search)
          const hasSignIn = await page
            .locator('input[type=password], button:has-text("Sign in"), button:has-text("Log in"), a:has-text("Sign in")')
            .first().isVisible({ timeout: 5_000 }).catch(() => false)

          expect(onLogin || hasSignIn,
            `${url} served an anonymous browser a page that is neither a login screen nor a `
            + `redirect to one — it landed on ${r.url} with ${r.textLen} chars of content. `
            + `This surface signs transactions.`).toBe(true)
        })
        continue
      }

      test(`${route} renders`, async ({ page, request }) => {
        const url = (await base(request)) + route
        const r = await expectRendered(page, url, `${s.label} ${route}`)
        console.log(`  ${route.padEnd(34)} HTTP ${String(r.status).padEnd(4)} `
          + `${String(r.textLen).padStart(6)} chars  ${r.heading ? `“${r.heading}”` : '(no heading)'}`)
        // Screenshot on PASS as well as fail — the fail path is shot-reporter's.
        await snap(page, `${s.id}-${name}`)
      })
    }

    // A surface that answers 200 for everything cannot tell you a route is
    // gone, so the ones that DO 404 honestly get that verified once. It is the
    // control that makes the rest of this file's status logging meaningful.
    if (!s.catchAll) {
      test('unknown route 404s (the status codes here mean something)', async ({ request }) => {
        const url = s.base + '/zzz-not-a-real-route-' + Date.now()
        const status = await httpStatus(request, url)
        console.log(`  control: ${url} → ${status}`)
        expect(status,
          `${s.label} answers ${status} for a path that does not exist, so no status code from `
          + `this origin is evidence of anything. Mark it catchAll in e2e/routes.ts.`).toBe(404)
      })
    }
  })
}

// ── Routes this deployment does not serve ──────────────────────────────────
// Not a failure — a RECORD. The explorer is a Blockscout build with several
// upstream pages switched off, and lux.build gates /builds behind auth. They
// are re-measured every run so that the day one of them starts serving, the log
// says so and it can be moved into the registry deliberately.
test.describe('Declared upstream but not served here', () => {
  for (const [id, routes] of Object.entries(NOT_SERVED)) {
    test(`${id}: ${routes.length} route(s) still absent`, async ({ request }) => {
      const s = SURFACES.find((x) => x.id === id)!
      const live: string[] = []
      for (const route of routes) {
        const status = await httpStatus(request, s.base + route)
        console.log(`  ${route.padEnd(20)} ${status}`)
        if (status === 200) live.push(route)
      }
      if (live.length) {
        console.log(`  NOTE: ${live.join(', ')} now serve(s) — move into SURFACES in e2e/routes.ts`)
      }
      // Nothing is asserted about absent pages. What IS asserted is that the
      // origin is up, so "all 404" never silently means "the host is gone".
      expect(await httpStatus(request, s.base),
        `${s.base} itself is unreachable — the 404s above are not about routes`).toBeGreaterThan(0)
    })
  }
})

// ── The one surface with no route list, because it has no /v1 ──────────────
// bridge-api.lux.network serves exactly two paths: `/` ("Hello, Winston
// Logger!") and `/health`, which embeds the MPC quorum state. There is no fee
// API behind the owner's "manage bridge fees" — the fee surface exists only in
// the MPC console at /bridge/fees, which is why that route is asserted as
// protected above. Recording the shape here so the gap is measured, not
// remembered.
test.describe('Bridge API', () => {
  test('/health reports the MPC quorum', async ({ request }) => {
    const res = await request.get('https://bridge-api.lux.network/health', { timeout: 15_000 })
    console.log(`  bridge-api /health: ${res.status()}`)
    expect(res.status()).toBe(200)
    const body = await res.text()
    const json = JSON.parse(body) as Record<string, unknown>
    console.log(`  ${JSON.stringify(json).slice(0, 300)}`)
    const mpc = JSON.stringify(json)
    expect(mpc, 'bridge-api /health no longer reports mpc node state').toMatch(/totalNodes|activeNodes|threshold/i)
  })

  test('there is still no /v1 fee API to manage', async ({ request }) => {
    // Asserted so the day one appears, this test goes red and the admin dash
    // can stop screen-scraping the MPC console for fees.
    const status = await httpStatus(request, 'https://bridge-api.lux.network/v1/health')
    console.log(`  bridge-api /v1/health: ${status} (404 = still no /v1 surface)`)
    expect(status).toBe(404)
  })
})