@jant/core 0.6.16 → 0.7.0

package/src/routes/pages/__tests__/post-preview-partial.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { partialPageRoutes } from "../partials.js";
+
+function createPartialTestApp(options: { authenticated?: boolean } = {}) {
+  const testApp = createTestApp(options);
+  testApp.app.route("/", partialPageRoutes);
+  return testApp;
+}
+
+describe("/_/post-preview/:postId", () => {
+  it("renders the post the way its own page does", async () => {
+    // The composer shows this while writing a translation, and the original's
+    // structure is part of what gets translated — so it has to arrive as the
+    // post, not as a body-only excerpt.
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      title: "Yirgacheffe",
+      bodyMarkdown: "## Brewing\n\nNinety-two degrees was too hot.",
+      status: "published",
+    });
+
+    const res = await app.request(`/_/post-preview/${post.id}`);
+
+    expect(res.status).toBe(200);
+    const html = await res.text();
+    expect(html).toContain("Yirgacheffe");
+    expect(html).toContain("Brewing");
+    expect(html).toContain("Ninety-two degrees was too hot.");
+    // Detail styling, not the feed card's summary.
+    expect(html).toContain("post-detail-title");
+  });
+
+  it("carries a quote's attribution, which a body-only preview would drop", async () => {
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    // A Quote stores its attribution in `title` / `url`; the API surfaces the
+    // same two as `sourceName` / `sourceUrl`.
+    const post = await services.posts.create({
+      format: "quote",
+      quoteText: "Focus is about saying no.",
+      title: "Some Author",
+      url: "https://example.com/focus",
+      status: "published",
+    });
+
+    const html = await (await app.request(`/_/post-preview/${post.id}`)).text();
+
+    expect(html).toContain("Focus is about saying no.");
+    expect(html).toContain("Some Author");
+    expect(html).toContain("https://example.com/focus");
+  });
+
+  it("offers no control that would act on the post being previewed", async () => {
+    // Every action in the composer belongs to the post being written. A menu
+    // or reply trigger here would aim at the wrong one.
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      title: "Yirgacheffe",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+
+    const html = await (await app.request(`/_/post-preview/${post.id}`)).text();
+
+    expect(html).not.toContain("data-post-menu-trigger");
+    expect(html).not.toContain("data-reply-trigger");
+  });
+
+  it("prints a titled post's date once, not in both header and footer", async () => {
+    // The card drops the footer's copy for a titled detail post, but only when
+    // `hideTimestamp` is left undefined — stating it either way brings it back.
+    const { app, services } = createPartialTestApp({ authenticated: true });
+    const post = await services.posts.create({
+      format: "note",
+      title: "Yirgacheffe",
+      bodyMarkdown: "Body",
+      status: "published",
+    });
+
+    const html = await (await app.request(`/_/post-preview/${post.id}`)).text();
+
+    expect(html.match(/<time/g) ?? []).toHaveLength(1);
+  });
+
+  it("404s on a post that is not there", async () => {
+    const { app } = createPartialTestApp({ authenticated: true });
+
+    const res = await app.request(
+      "/_/post-preview/pst_01000000000000000000000000",
+    );
+
+    expect(res.status).toBe(404);
+  });
+});

package/src/routes/pages/__tests__/smart-collection.test.ts

@@ -0,0 +1,298 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../__tests__/helpers/app.js";
+import { pageRoutes } from "../page.js";
+
+/**
+ * The smart collection page, end to end through the path registry.
+ *
+ * The property these guard is the one the design turns on: a smart collection
+ * is always public, and the posts inside it are exactly as visible as they are
+ * anywhere else. Those are different sentences, and confusing them is how a
+ * page ends up either 404ing for readers or leaking a draft.
+ */
+
+function setup(authenticated = false) {
+  const { app, services } = createTestApp({ authenticated });
+  app.route("/", pageRoutes);
+  return { app, services };
+}
+
+async function seedQuotes(services: {
+  posts: {
+    create: (input: Record<string, unknown>) => Promise<{ id: string }>;
+  };
+}) {
+  await services.posts.create({
+    format: "quote",
+    quoteText: "A public quote",
+    bodyMarkdown: "public quote body",
+    status: "published",
+  });
+  await services.posts.create({
+    format: "quote",
+    quoteText: "A private quote",
+    bodyMarkdown: "private quote body",
+    status: "published",
+    visibility: "private",
+  });
+  await services.posts.create({
+    format: "note",
+    bodyMarkdown: "a plain note body",
+    status: "published",
+  });
+}
+
+describe("smart collection page", () => {
+  it("renders for a signed-out reader, with title, count, and description", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      description: "Things worth keeping.",
+      selection: { format: "quote" },
+    });
+
+    const res = await app.request("/quotes");
+    expect(res.status).toBe(200);
+    const html = await res.text();
+
+    expect(html).toContain("Quotes");
+    expect(html).toContain("Things worth keeping.");
+    // A written description takes the slot; the conditions — and the way to
+    // the archive — stay reachable through the marker beside the title.
+    expect(html).not.toContain(">Automatically collects: Quotes<");
+    expect(html).toContain('title="Automatically collects: Quotes"');
+    expect(html).toContain(
+      '<a href="/archive?format=quote" class="collection-page-smart-icon"',
+    );
+    expect(html).toContain("public quote body");
+    expect(html).not.toContain("a plain note body");
+    // The archive has a chip bar; this page does not.
+    expect(html).not.toContain("archive-filters-chips");
+  });
+
+  it("describes itself by its conditions until a description is written", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+
+    const html = await (await app.request("/quotes")).text();
+    expect(html).toContain(">Automatically collects: Quotes<");
+  });
+
+  it("links its conditions to the archive showing the same posts", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote", media: "none" },
+    });
+
+    const html = await (await app.request("/quotes")).text();
+    expect(html).toContain("/archive?format=quote&amp;media=none");
+  });
+
+  it("says so when nothing matches, rather than rendering blank", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "links",
+      title: "Links",
+      selection: { format: "link" },
+    });
+
+    const html = await (await app.request("/links")).text();
+    expect(html).toContain("Nothing matches these conditions yet.");
+  });
+
+  it("collects every post when no condition narrows it", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "everything",
+      title: "Everything",
+    });
+
+    const html = await (await app.request("/everything")).text();
+    expect(html).toContain("Automatically collects every post.");
+    expect(html).toContain("public quote body");
+    expect(html).toContain("a plain note body");
+  });
+
+  // The whole point of forbidding private conditions: there is no smart
+  // collection page that answers 404 to a reader.
+  it("shows the private post to its author and to nobody else", async () => {
+    const reader = setup(false);
+    await seedQuotes(reader.services);
+    await reader.services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+    const readerHtml = await (await reader.app.request("/quotes")).text();
+    expect(readerHtml).toContain("public quote body");
+    expect(readerHtml).not.toContain("private quote body");
+    expect(readerHtml).toContain("1 thread");
+
+    const authorApp = setup(true);
+    await seedQuotes(authorApp.services);
+    await authorApp.services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+    const authorHtml = await (await authorApp.app.request("/quotes")).text();
+    expect(authorHtml).toContain("private quote body");
+    expect(authorHtml).toContain("2 threads");
+  });
+
+  it("ignores condition parameters in the URL", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+
+    // Membership is edited in the dialog. A reader appending `?format=note`
+    // must not be able to redefine what the page collects.
+    const html = await (await app.request("/quotes?format=note")).text();
+    expect(html).toContain("public quote body");
+    expect(html).not.toContain("a plain note body");
+  });
+
+  it("honors ?sort= over the stored default", async () => {
+    const { app, services } = setup();
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Older",
+      bodyMarkdown: "older body",
+      status: "published",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Newer",
+      bodyMarkdown: "newer body",
+      status: "published",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+      sort: "newest",
+    });
+
+    const stored = await (await app.request("/quotes")).text();
+    expect(stored.indexOf("newer body")).toBeLessThan(
+      stored.indexOf("older body"),
+    );
+
+    const flipped = await (await app.request("/quotes?sort=oldest")).text();
+    expect(flipped.indexOf("older body")).toBeLessThan(
+      flipped.indexOf("newer body"),
+    );
+  });
+
+  it("orders newest by date, not by rating", async () => {
+    const { app, services } = setup();
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Older",
+      bodyMarkdown: "older body",
+      status: "published",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+      rating: 5,
+    });
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Newer",
+      bodyMarkdown: "newer body",
+      status: "published",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+      rating: 1,
+    });
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+      sort: "newest",
+    });
+
+    // The page once handed `newest` to a query that read it as the ascending
+    // rating order, which put the worst-rated post on top of a dated page.
+    const page = await (await app.request("/quotes")).text();
+    expect(page.indexOf("newer body")).toBeLessThan(page.indexOf("older body"));
+  });
+
+  it("still answers a link to the retired ?sort=updated", async () => {
+    const { app, services } = setup();
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Older",
+      bodyMarkdown: "older body",
+      status: "published",
+      publishedAt: Date.UTC(2024, 0, 1) / 1000,
+    });
+    await services.posts.create({
+      format: "quote",
+      quoteText: "Newer",
+      bodyMarkdown: "newer body",
+      status: "published",
+      publishedAt: Date.UTC(2026, 0, 1) / 1000,
+    });
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+      // A stored order the legacy value must not fall back to, or the test
+      // would pass on the fallback rather than on the mapping.
+      sort: "oldest",
+    });
+
+    const legacy = await (await app.request("/quotes?sort=updated")).text();
+    expect(legacy.indexOf("newer body")).toBeLessThan(
+      legacy.indexOf("older body"),
+    );
+  });
+
+  it("404s an address no smart collection holds", async () => {
+    const { app } = setup();
+    expect((await app.request("/nothing-here")).status).toBe(404);
+  });
+});
+
+describe("smart collection feed", () => {
+  it("serves an anonymous feed with no guard to trip over", async () => {
+    const { app, services } = setup();
+    await seedQuotes(services);
+    await services.smartCollections.create({
+      slug: "quotes",
+      title: "Quotes",
+      selection: { format: "quote" },
+    });
+
+    const res = await app.request("/quotes/feed");
+    expect(res.status).toBe(200);
+    const xml = await res.text();
+
+    expect(xml).toContain("A public quote");
+    // A feed carries no session, so the private quote can never appear in one.
+    expect(xml).not.toContain("A private quote");
+    expect(xml).toContain('rel="self"');
+    expect(xml).toContain("/quotes/feed");
+  });
+
+  it("404s a feed for an address no smart collection holds", async () => {
+    const { app } = setup();
+    expect((await app.request("/nothing-here/feed")).status).toBe(404);
+  });
+});

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);
+  });
+});