website

import { after, before, describe, test } from "node:test";
import assert from "node:assert/strict";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { chromium } from "playwright";
import { startStaticServer } from "./helpers/static-server.js";

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const distDir = path.join(__dirname, "..", "dist");

let server;
let browser;
let page;
const consoleErrors = [];

before(async () => {
  server = await startStaticServer(distDir);
  browser = await chromium.launch();
  page = await browser.newPage();
  page.on("console", (msg) => {
    if (msg.type() === "error") consoleErrors.push(`[${page.url()}] ${msg.text()}`);
  });
  page.on("pageerror", (err) => {
    consoleErrors.push(`[${page.url()}] ${err.message}`);
  });
});

after(async () => {
  await browser?.close();
  await server?.close();
});

async function goto(urlPath) {
  const response = await page.goto(`${server.url}${urlPath}`, { waitUntil: "domcontentloaded" });
  return response;
}

describe("static pages", () => {
  test("home page renders", async () => {
    const response = await goto("/");
    assert.equal(response.status(), 200);
    await assert.doesNotReject(page.locator("h1.title").waitFor());
    assert.match(await page.title(), /pyrossh/);
  });

  test("cv page renders", async () => {
    const response = await goto("/cv/");
    assert.equal(response.status(), 200);
    await assert.doesNotReject(page.locator("h1").waitFor());
    assert.equal(await page.locator("img[alt='Resume']").count(), 1);
  });

  test("posts index lists posts", async () => {
    const response = await goto("/posts/");
    assert.equal(response.status(), 200);
    const links = page.locator("main a[href^='/posts/']");
    assert.ok((await links.count()) > 0, "expected at least one post link");
  });

  test("a post page renders", async () => {
    const response = await goto("/posts/react-powertools-swr/");
    assert.equal(response.status(), 200);
    assert.match(await page.title(), /React Powertools/);
  });

  test("only-bible-app pages render", async () => {
    for (const url of ["/only-bible-app/", "/only-bible-app/privacy-policy/", "/only-bible-app/terms-and-conditions/"]) {
      const response = await goto(url);
      assert.equal(response.status(), 200, `expected 200 for ${url}`);
    }
  });

  test("robots.txt and rss.xml are served", async () => {
    const robots = await goto("/robots.txt");
    assert.equal(robots.status(), 200);
    assert.match(await page.content(), /User-agent/);

    const rss = await goto("/rss.xml");
    assert.equal(rss.status(), 200);
  });

  test("unknown route returns the 404 page", async () => {
    const response = await goto("/this-page-does-not-exist/");
    assert.equal(response.status(), 404);
    assert.match(await page.locator("h1").textContent(), /404/);
  });
});

describe("repo pages", () => {
  const repoId = "website";

  test("repo readme page renders", async () => {
    const response = await goto(`/repos/${repoId}/`);
    assert.equal(response.status(), 200);
    await assert.doesNotReject(page.locator(".repo .header h1").waitFor());
    assert.equal(await page.locator(".nav a.active-tab").textContent(), "Readme");
  });

  test("repo commits page lists commits", async () => {
    const response = await goto(`/repos/${repoId}/commits/`);
    assert.equal(response.status(), 200);
    const commitLinks = page.locator(`a[href^='/repos/${repoId}/commits/']`);
    assert.ok((await commitLinks.count()) > 0, "expected at least one commit link");
  });

  test("a single commit page renders", async () => {
    await goto(`/repos/${repoId}/commits/`);
    const firstCommitHref = await page.locator(`a[href^='/repos/${repoId}/commits/']`).first().getAttribute("href");
    const response = await goto(firstCommitHref);
    assert.equal(response.status(), 200);
    assert.equal(await page.locator(".nav a.active-tab").textContent(), "Commits");
  });

  test("repo files index renders the tree and a default file", async () => {
    const response = await goto(`/repos/${repoId}/files/`);
    assert.equal(response.status(), 200);
    assert.ok((await page.locator(".file-explorer-tree").count()) > 0);
  });

  test("a specific file, its history and blame views render", async () => {
    const filePath = "eleventy.config.js";
    const fileRes = await goto(`/repos/${repoId}/files/${filePath}/`);
    assert.equal(fileRes.status(), 200);

    const historyRes = await goto(`/repos/${repoId}/files/${filePath}/history/`);
    assert.equal(historyRes.status(), 200);

    const blameRes = await goto(`/repos/${repoId}/files/${filePath}/blame/`);
    assert.equal(blameRes.status(), 200);
  });

  test("repo nav tabs swap content via htmx without a full reload", async () => {
    await goto(`/repos/${repoId}/`);
    await page.click(".nav a[href='/repos/website/files/']");
    await page.waitForURL(`${server.url}/repos/${repoId}/files/`);
    assert.equal(await page.locator(".nav a.active-tab").textContent(), "Code");
  });
});

test("no unexpected console errors were logged across visited pages", () => {
  // The deliberate 404 test above triggers a browser-level "failed to load
  // resource" console entry for its own navigation request — that's the
  // behavior under test there, not a bug, so it's excluded here.
  const unexpected = consoleErrors.filter((msg) => !msg.includes("this-page-does-not-exist"));
  assert.deepEqual(unexpected, []);
});