@jant/core 0.6.16 → 0.7.1

package/src/routes/pages/__tests__/subscribe.test.ts

@@ -0,0 +1,248 @@
+/**
+ * The subscribe page.
+ *
+ * What is under test is mostly the page's contract with readers: three feeds on
+ * every site, whole addresses that survive being pasted into a reader, and the
+ * right pair for whichever end `/feed` currently returns. Getting the pairing
+ * wrong would list the same feed twice under two names — the confusion this
+ * page exists to end.
+ */
+
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { i18nMiddleware } from "../../../i18n/index.js";
+import { languageRoutes } from "../language.js";
+import { pageRoutes } from "../page.js";
+import { subscribeRoutes } from "../subscribe.js";
+
+function createSubscribeTestApp() {
+  const testApp = createTestApp();
+  const { app } = testApp;
+
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+  app.use("*", i18nMiddleware());
+
+  app.route("/subscribe", subscribeRoutes);
+  app.route("/:lang", languageRoutes);
+  app.route("/", pageRoutes);
+
+  return testApp;
+}
+
+/** Every address the page offers for copying, in document order. */
+function feedAddresses(html: string): string[] {
+  return [...html.matchAll(/<input[^>]*>/g)]
+    .filter((match) => match[0].includes("data-copy-field-value"))
+    .map((match) => /value="([^"]*)"/.exec(match[0])?.[1] ?? "");
+}
+
+/**
+ * The addresses as paths, for asserting which feeds are offered without
+ * pinning the test to the host the test app happens to run under.
+ */
+function feedPaths(html: string): string[] {
+  return feedAddresses(html).map((address) => new URL(address).pathname);
+}
+
+/** Where each feed's name links, in document order. */
+function labelLinks(html: string): string[] {
+  return [
+    ...html.matchAll(/<a href="([^"]*)" title="Open the page[^"]*"/g),
+  ].map((match) => match[1] ?? "");
+}
+
+describe("subscribe page", () => {
+  it("offers the main feed, the other end of the list, and the archive", async () => {
+    const { app, services } = createSubscribeTestApp();
+    await services.settings.set("MAIN_RSS_FEED", "latest");
+
+    const res = await app.request("/subscribe");
+    const html = await res.text();
+
+    expect(res.status).toBe(200);
+    expect(feedPaths(html)).toEqual([
+      "/feed",
+      "/featured/feed",
+      "/archive/feed",
+    ]);
+  });
+
+  // `/feed` already returns the featured posts here, so offering
+  // `/featured/feed` beside it would be one feed under two names.
+  it("offers the latest feed when the main feed is the featured one", async () => {
+    const { app, services } = createSubscribeTestApp();
+    await services.settings.set("MAIN_RSS_FEED", "featured");
+
+    const html = await (await app.request("/subscribe")).text();
+
+    expect(feedPaths(html)).toEqual(["/feed", "/latest/feed", "/archive/feed"]);
+  });
+
+  it("names the main feed by what it currently carries", async () => {
+    const { app, services } = createSubscribeTestApp();
+    await services.settings.set("MAIN_RSS_FEED", "latest");
+    const latest = await (await app.request("/subscribe")).text();
+
+    await services.settings.set("MAIN_RSS_FEED", "featured");
+    const featured = await (await app.request("/subscribe")).text();
+
+    expect(latest).toContain("The same posts as the home page.");
+    expect(featured).toContain("Only the posts marked as featured.");
+  });
+
+  // Each feed is the feed of a page, and the page is the only honest preview
+  // of what subscribing gets you — a sentence can only approximate it.
+  it("links each feed to the page whose posts it carries", async () => {
+    const { app, services } = createSubscribeTestApp();
+    await services.settings.set("MAIN_RSS_FEED", "latest");
+
+    const html = await (await app.request("/subscribe")).text();
+
+    // `/latest` only redirects to `/`, so the latest feed links straight at
+    // the home page rather than sending readers through a 302.
+    expect(labelLinks(html)).toEqual(["/", "/featured", "/archive"]);
+  });
+
+  // The main feed is one of the other two under a different name. If its
+  // description and its page link were built separately they could drift, and
+  // the page would be describing one feed while linking at another.
+  it("gives the main feed the same description and page as the feed it is", async () => {
+    const { app, services } = createSubscribeTestApp();
+
+    await services.settings.set("MAIN_RSS_FEED", "featured");
+    const featured = await (await app.request("/subscribe")).text();
+    // Main feed first, then the opposite end (`latest`), then the archive.
+    expect(labelLinks(featured)).toEqual(["/featured", "/", "/archive"]);
+    expect([
+      ...featured.matchAll(/Only the posts marked as featured\./g),
+    ]).toHaveLength(1);
+
+    await services.settings.set("MAIN_RSS_FEED", "latest");
+    const latest = await (await app.request("/subscribe")).text();
+    expect(labelLinks(latest)).toEqual(["/", "/featured", "/archive"]);
+  });
+
+  // A reader who wants more than these two paragraphs needs somewhere to go,
+  // and it must not be a page about Jant.
+  it("points at an outside introduction, opened safely", async () => {
+    const { app } = createSubscribeTestApp();
+
+    const html = await (await app.request("/subscribe")).text();
+
+    const link = /<a[^>]*href="https:\/\/aboutfeeds\.com\/"[^>]*>/.exec(
+      html,
+    )?.[0];
+    expect(link).toBeDefined();
+    expect(link).toContain('rel="noopener noreferrer"');
+    expect(link).toContain('target="_blank"');
+  });
+
+  // The description has to say what the archive feed adds, not sound like the
+  // default choice.
+  it("says what the archive feed carries beyond the others", async () => {
+    const { app } = createSubscribeTestApp();
+
+    const html = await (await app.request("/subscribe")).text();
+
+    expect(html).toContain(
+      "Every published post, including those kept off the home page.",
+    );
+  });
+
+  // The addresses are the whole content of this page. A reader with scripts off
+  // must still be able to select and copy them, so the server renders the field
+  // and ships the button hidden rather than leaving a dead control.
+  it("renders every address without waiting for JavaScript", async () => {
+    const { app } = createSubscribeTestApp();
+
+    const html = await (await app.request("/subscribe")).text();
+
+    const addresses = feedAddresses(html);
+    expect(addresses).toHaveLength(3);
+    // Whole addresses: a path pasted into a feed reader resolves nowhere.
+    for (const address of addresses) {
+      expect(address).toMatch(/^https?:\/\/[^/]+\//);
+    }
+    expect(html).toContain("data-copy-field-root");
+    expect(/<button[^>]*hidden[^>]*data-copy-field=/.test(html)).toBe(true);
+  });
+
+  // The page is about feeds and used to carry no feed mark at all, while its
+  // closing note tells the reader to look for that glyph on other pages. The
+  // note only works once the glyph has been shown here.
+  it("shows the feed glyph it tells readers to look for", async () => {
+    const { app } = createSubscribeTestApp();
+
+    const html = await (await app.request("/subscribe")).text();
+
+    // Once beside the page title, once as the specimen the closing note
+    // points at.
+    expect([...html.matchAll(/lucide-rss/g)]).toHaveLength(2);
+    expect(html).toContain("Look for this icon on those pages.");
+  });
+
+  // A reader who has never used a feed reader is handed three addresses and no
+  // idea what to do with them — the same dead end this page exists to end, one
+  // step later. No product names: the list would be identical on every Jant
+  // site, and it would rot.
+  it("explains what a feed reader is without naming one", async () => {
+    const { app } = createSubscribeTestApp();
+
+    const html = await (await app.request("/subscribe")).text();
+
+    expect(html).toContain("What a feed reader does");
+    expect(html).toContain(
+      "A feed reader checks these addresses for new posts",
+    );
+    expect(html).toContain("Subscribing creates no account here.");
+  });
+
+  it("404s when feeds are switched off site-wide", async () => {
+    const { app, services } = createSubscribeTestApp();
+    await services.settings.set("RSS_FEEDS_ENABLED", "false");
+
+    const res = await app.request("/subscribe");
+
+    expect(res.status).toBe(404);
+  });
+
+  it("serves a language view with that language's addresses", async () => {
+    const { app, services } = createSubscribeTestApp();
+    await services.settings.set("SITE_LANGUAGE", "en");
+    await services.settings.set("ADDITIONAL_LANGUAGES", "ja");
+    await services.settings.set("MULTILINGUAL_ENABLED", "true");
+    await services.settings.set("MAIN_RSS_FEED", "latest");
+
+    const res = await app.request("/ja/subscribe");
+    const html = await res.text();
+
+    expect(res.status).toBe(200);
+    expect(feedPaths(html)).toEqual([
+      "/ja/feed",
+      "/ja/featured/feed",
+      "/ja/archive/feed",
+    ]);
+  });
+
+  // A slug may not shadow the page: `subscribe` is in RESERVED_PATHS, so this
+  // never becomes a post's address in the first place.
+  it("keeps the path for the page rather than a post", async () => {
+    const { app, services } = createSubscribeTestApp();
+
+    await expect(
+      services.posts.create({
+        format: "note",
+        title: "Subscribe",
+        slug: "subscribe",
+        bodyMarkdown: "Trying to take the path",
+        status: "published",
+      }),
+    ).rejects.toThrow();
+
+    expect((await app.request("/subscribe")).status).toBe(200);
+  });
+});

package/src/routes/pages/__tests__/thread-order.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Thread order on the public surfaces when a reply is older than its root.
+ *
+ * A post moved into a Thread keeps its own creation time, and an export
+ * without `created` dates every post by its publication, so a Thread's replies
+ * can carry a `createdAt` earlier than the root's. Thread order still opens on
+ * the root: every page and feed that reads the first post as the root has to
+ * find it there, or the Thread drops out of Featured and Collections and its
+ * page canonicalizes to a reply.
+ */
+
+import { eq } from "drizzle-orm";
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { posts as postTable } from "../../../db/schema.js";
+import { toISOString } from "../../../lib/time.js";
+import { collectionRoutes } from "../collection.js";
+import { collectionsPageRoutes } from "../collections.js";
+import { featuredRoutes } from "../featured.js";
+import { pageRoutes } from "../page.js";
+
+const ROOT_TEXT = "Root body text";
+const FIRST_TEXT = "First reply text";
+const SECOND_TEXT = "Second reply text";
+
+function createThreadOrderTestApp(options: { authenticated?: boolean } = {}) {
+  const testApp = createTestApp(options);
+  const { app } = testApp;
+
+  app.use("*", async (c, next) => {
+    c.set("publicPath", c.req.path);
+    c.set("publicRequestUrl", c.req.url);
+    await next();
+  });
+
+  app.route("/featured", featuredRoutes);
+  app.route("/collections", collectionsPageRoutes);
+  app.route("/collections", collectionRoutes);
+  app.route("/", pageRoutes);
+
+  return testApp;
+}
+
+/**
+ * A featured root published after its two replies, with creation times to
+ * match — the shape a site rebuilt from a pre-`created` export holds.
+ */
+async function createThreadWithOlderReplies(
+  testApp: ReturnType<typeof createThreadOrderTestApp>,
+) {
+  const { services, db } = testApp;
+  const root = await services.posts.create({
+    format: "note",
+    title: "Thread root",
+    bodyMarkdown: ROOT_TEXT,
+    featured: true,
+    publishedAt: 3000,
+  });
+  const first = await services.posts.create({
+    format: "note",
+    bodyMarkdown: FIRST_TEXT,
+    replyToId: root.id,
+    publishedAt: 1000,
+  });
+  const second = await services.posts.create({
+    format: "note",
+    bodyMarkdown: SECOND_TEXT,
+    replyToId: first.id,
+    publishedAt: 2000,
+  });
+  for (const [id, createdAt] of [
+    [root.id, 3000],
+    [first.id, 1000],
+    [second.id, 2000],
+  ] as const) {
+    await db.update(postTable).set({ createdAt }).where(eq(postTable.id, id));
+  }
+  return { root, first, second };
+}
+
+/**
+ * Assert the three posts appear root first, in Thread order. A page's `<head>`
+ * repeats the visited post's text, so only the body counts.
+ */
+function expectRootFirst(markup: string) {
+  const bodyStart = markup.indexOf("<body");
+  const body = bodyStart === -1 ? markup : markup.slice(bodyStart);
+  const root = body.indexOf(ROOT_TEXT);
+  const first = body.indexOf(FIRST_TEXT);
+  const second = body.indexOf(SECOND_TEXT);
+  expect(root).toBeGreaterThan(-1);
+  expect(first).toBeGreaterThan(root);
+  expect(second).toBeGreaterThan(first);
+}
+
+/** The post whose `<article>` holds the markup at `index`. */
+function postIdAt(html: string, index: number): string | undefined {
+  const articles = html
+    .slice(0, index)
+    .matchAll(/<article\b[^>]*\bdata-post-id="([^"]+)"/g);
+  return [...articles].at(-1)?.[1];
+}
+
+function extractCanonicalHref(html: string): string | null {
+  const match = html.match(/<link\s+rel="canonical"\s+href="([^"]+)"\s*\/?>/i);
+  return match?.[1] ?? null;
+}
+
+describe("Thread order with replies older than the root", () => {
+  it("opens the Thread page on the root and points its canonical there", async () => {
+    const testApp = createThreadOrderTestApp();
+    const { root, second } = await createThreadWithOlderReplies(testApp);
+
+    const res = await testApp.app.request(`/${second.slug}`);
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expectRootFirst(html);
+    expect(extractCanonicalHref(html)).toMatch(new RegExp(`/${root.slug}$`));
+    // The page describes the Thread as one article, dated by its root.
+    expect(html).toContain(
+      `<meta property="article:published_time" content="${toISOString(3000)}"/>`,
+    );
+    expect(html).toContain(`"datePublished":"${toISOString(3000)}"`);
+  });
+
+  it("offers the author a reply on the newest reply, not the root", async () => {
+    const testApp = createThreadOrderTestApp({ authenticated: true });
+    const { root, second } = await createThreadWithOlderReplies(testApp);
+
+    const html = await (await testApp.app.request(`/${root.slug}`)).text();
+
+    expect(html.match(/data-reply-trigger/g)).toHaveLength(1);
+    expect(postIdAt(html, html.indexOf("data-reply-trigger"))).toBe(second.id);
+  });
+
+  it("keeps the Thread on the Featured page", async () => {
+    const testApp = createThreadOrderTestApp();
+    await createThreadWithOlderReplies(testApp);
+
+    const res = await testApp.app.request("/featured");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    // The curated view shows the root and the Thread's final post, with the
+    // reply between them folded into a gap.
+    expect(html).toContain(ROOT_TEXT);
+    expect(html).not.toContain(FIRST_TEXT);
+    expect(html.indexOf(SECOND_TEXT)).toBeGreaterThan(html.indexOf(ROOT_TEXT));
+  });
+
+  it("keeps the Thread in the Featured feed", async () => {
+    const testApp = createThreadOrderTestApp();
+    const { root } = await createThreadWithOlderReplies(testApp);
+
+    const res = await testApp.app.request("/featured/feed");
+    expect(res.status).toBe(200);
+    const xml = await res.text();
+
+    expect(xml.match(/<entry>/g)).toHaveLength(1);
+    expect(xml).toContain(`/${root.slug}`);
+    expectRootFirst(xml);
+  });
+
+  it("opens the Thread on its root on a Collection page", async () => {
+    const testApp = createThreadOrderTestApp();
+    const collection = await testApp.services.collections.create({
+      slug: "reading",
+      title: "Reading",
+    });
+    const { root } = await createThreadWithOlderReplies(testApp);
+    await testApp.services.collections.addThread(collection.id, root.id);
+
+    const res = await testApp.app.request(`/${collection.slug}`);
+    expect(res.status).toBe(200);
+
+    expectRootFirst(await res.text());
+  });
+});