mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-16 05:01:03 +03:00
148 lines
6.7 KiB
TypeScript
148 lines
6.7 KiB
TypeScript
import { describe, expect, test } from "bun:test"
|
|
import { fileURLToPath } from "node:url"
|
|
// SolidStart's own file router, which builds the route manifest the app serves /sitemap-pages.xml from.
|
|
import { DEFAULT_EXTENSIONS } from "../node_modules/@solidjs/start/dist/config/constants.js"
|
|
import { SolidStartServerFileRouter } from "../node_modules/@solidjs/start/dist/config/fs-router.js"
|
|
import { config } from "~/config"
|
|
import type { ChangelogRelease } from "~/lib/changelog"
|
|
import { LOCALES, strip } from "~/lib/language"
|
|
import { legalDocuments } from "~/lib/legal-documents"
|
|
import {
|
|
sitemapExclusion,
|
|
sitemapExclusions,
|
|
sitemapFiles,
|
|
sitemapIndexXml,
|
|
sitemapLimits,
|
|
sitemapPages,
|
|
sitemapXml,
|
|
unlistedRoutes,
|
|
} from "~/lib/sitemap"
|
|
|
|
const router = new SolidStartServerFileRouter({
|
|
dir: fileURLToPath(new URL("../src/routes", import.meta.url)),
|
|
extensions: DEFAULT_EXTENSIONS,
|
|
})
|
|
const manifest: { path: string; page?: boolean }[] = await router.getRoutes()
|
|
const routes = manifest.filter((route) => route.page).map((route) => route.path)
|
|
|
|
const release = (index: number): ChangelogRelease => ({
|
|
tag: `v2.0.${index}`,
|
|
name: `v2.0.${index}`,
|
|
// One release a day, so none merge.
|
|
date: new Date(Date.UTC(2026, 0, 1) + index * 86_400_000).toISOString(),
|
|
url: `https://github.com/anomalyco/opencode/releases/tag/v2.0.${index}`,
|
|
highlights: [],
|
|
sections: [],
|
|
notes: {
|
|
features: [{ title: `Feature ${index}`, body: "", areas: ["Core"], prs: [], credits: [] }],
|
|
breaking: [],
|
|
improved: [{ text: `Improvement ${index}`, areas: ["Core"], prs: [], credits: [] }],
|
|
fixed: [],
|
|
media: [],
|
|
},
|
|
})
|
|
const releases = Array.from({ length: 3 }, (_, index) => release(index + 1)).toReversed()
|
|
const xml = sitemapXml(sitemapPages(routes, { releases }))
|
|
const urls = [...xml.matchAll(/<loc>([^<]+)<\/loc>/g)].map((match) => match[1])
|
|
|
|
describe("sitemap", () => {
|
|
test("/sitemap.xml is an index of this site's sitemaps, with the pages and the V2 docs at /docs", () => {
|
|
const index = sitemapIndexXml(sitemapFiles)
|
|
const files = [...index.matchAll(/<sitemap><loc>([^<]+)<\/loc><\/sitemap>/g)].map((match) => match[1])
|
|
expect(index).toContain('<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">')
|
|
expect(files).toEqual(sitemapFiles.map((file) => `${config.baseUrl}${file}`))
|
|
expect(files).toContain(`${config.baseUrl}/sitemap-pages.xml`)
|
|
expect(files).toContain(`${config.baseUrl}/docs/sitemap.xml`)
|
|
expect(files.some((file) => file === `${config.baseUrl}/sitemap.xml`)).toBe(false)
|
|
})
|
|
|
|
test("lists every public page route, or excludes it with a reason", () => {
|
|
expect(unlistedRoutes(routes)).toEqual([])
|
|
const listed = new Set(urls.map((url) => strip(new URL(url).pathname)))
|
|
const missing = routes
|
|
.map((path) => (path.length > 1 ? path.replace(/\/$/, "") : path))
|
|
.filter((path) => !/[:*]/.test(path) && !sitemapExclusion(path) && !listed.has(path))
|
|
expect(missing).toEqual([])
|
|
})
|
|
|
|
test("every exclusion still matches a route", () => {
|
|
const stale = Object.keys(sitemapExclusions).filter(
|
|
(pattern) =>
|
|
!routes.some((path) =>
|
|
pattern.endsWith("/*") ? path.startsWith(pattern.slice(0, -2)) : path.replace(/(.)\/$/, "$1") === pattern,
|
|
),
|
|
)
|
|
expect(stale).toEqual([])
|
|
})
|
|
|
|
test("every URL is served by a page route", () => {
|
|
const patterns = routes
|
|
.filter((path) => !sitemapExclusion(path.replace(/(.)\/$/, "$1")))
|
|
.map((path) => ({
|
|
path,
|
|
regex: new RegExp(
|
|
`^${path
|
|
.replace(/(.)\/$/, "$1")
|
|
.replace(/\*[^/]*/g, ".+")
|
|
.replace(/:[^/]+/g, "[^/]+")}$`,
|
|
),
|
|
}))
|
|
const tags = new Set(releases.map((item) => item.tag))
|
|
const unserved = urls.filter((url) => {
|
|
expect(url.startsWith(`${config.baseUrl}/`)).toBe(true)
|
|
const path = strip(new URL(url).pathname)
|
|
// A dynamic URL must come from the data its page reads: the catch-all 404 is excluded above.
|
|
const tag = path.match(/^\/changelog\/([^/]+)$/)?.[1]
|
|
if (tag) return !tags.has(tag)
|
|
return !patterns.some((pattern) => pattern.regex.test(path))
|
|
})
|
|
expect(unserved).toEqual([])
|
|
expect(new Set(urls).size).toBe(urls.length)
|
|
})
|
|
|
|
test("lists localized pages in every locale with hreflang alternates, and legal pages once", () => {
|
|
expect(urls.filter((url) => strip(new URL(url).pathname) === "/")).toHaveLength(LOCALES.length)
|
|
expect(xml).toContain(`<xhtml:link rel="alternate" hreflang="zh-Hans" href="${config.baseUrl}/zh/product"/>`)
|
|
expect(xml).toContain(`<xhtml:link rel="alternate" hreflang="x-default" href="${config.baseUrl}/product"/>`)
|
|
legalDocuments.forEach((document) => {
|
|
expect(urls.filter((url) => url.endsWith(document.path))).toEqual([`${config.baseUrl}${document.path}`])
|
|
})
|
|
expect(xml).toContain(`<loc>${config.baseUrl}/changelog/v2.0.3</loc><lastmod>2026-01-04</lastmod>`)
|
|
expect(urls.some((url) => /\/(dev|workspace|legal\/subprocessors)(\/|$)/.test(url))).toBe(false)
|
|
})
|
|
|
|
test("lists the changelog once, in English, with only en and x-default alternates", () => {
|
|
const changelog = urls.filter((url) => /\/changelog(\/|$)/.test(new URL(url).pathname))
|
|
expect(changelog).toEqual([
|
|
`${config.baseUrl}/changelog`,
|
|
...releases.map((item) => `${config.baseUrl}/changelog/${item.tag}`),
|
|
])
|
|
const entry = xml.split("\n").find((line) => line.includes(`<loc>${config.baseUrl}/changelog/v2.0.3</loc>`))
|
|
expect(
|
|
[...(entry ?? "").matchAll(/hreflang="([^"]+)" href="([^"]+)"/g)].map((match) => [match[1], match[2]]),
|
|
).toEqual([
|
|
["en", `${config.baseUrl}/changelog/v2.0.3`],
|
|
["x-default", `${config.baseUrl}/changelog/v2.0.3`],
|
|
])
|
|
})
|
|
|
|
test("lists the font once, in English, with only en and x-default alternates", () => {
|
|
expect(urls.filter((url) => new URL(url).pathname.endsWith("/font"))).toEqual([`${config.baseUrl}/font`])
|
|
expect(xml).toContain(
|
|
`<url><loc>${config.baseUrl}/font</loc><xhtml:link rel="alternate" hreflang="en" href="${config.baseUrl}/font"/><xhtml:link rel="alternate" hreflang="x-default" href="${config.baseUrl}/font"/></url>`,
|
|
)
|
|
})
|
|
|
|
test("leaves out /zen, which redirects to the Console", () => {
|
|
expect(urls.some((url) => /\/zen(\/|$)/.test(new URL(url).pathname))).toBe(false)
|
|
})
|
|
|
|
test("stays inside the single-file limits with the most releases the changelog loads", () => {
|
|
const most = sitemapXml(
|
|
sitemapPages(routes, { releases: Array.from({ length: 300 }, (_, index) => release(index + 1)) }),
|
|
)
|
|
expect(most.match(/<loc>/g)?.length ?? 0).toBeLessThan(sitemapLimits.urls)
|
|
expect(new TextEncoder().encode(most).length).toBeLessThan(sitemapLimits.bytes)
|
|
})
|
|
})
|