src/frame/tests/pages.ts

import path from 'path'

import { beforeAll, describe, expect, test, vi } from 'vitest'
import GithubSlugger from 'github-slugger'
import { decode } from 'html-entities'
import { chain, pick } from 'lodash-es'

import { loadPages } from '@/frame/lib/page-data'
import libLanguages from '@/languages/lib/languages-server'
import { liquid } from '@/content-render/index'
import patterns from '@/frame/lib/patterns'
import removeFPTFromPath from '@/versions/lib/remove-fpt-from-path'
import type { Page } from '@/types'

const languageCodes = Object.keys(libLanguages)
const slugger = new GithubSlugger()

describe('pages module', () => {
  vi.setConfig({ testTimeout: 60 * 1000 })

  let pages: Page[]

  beforeAll(async () => {
    pages = await loadPages()
  })

  describe('loadPages', () => {
    test('yields a non-empty array of Page objects', async () => {
      expect(Array.isArray(pages)).toBe(true)
      expect(pages.length).toBeGreaterThan(100)
    })

    test('every page has a `languageCode`', async () => {
      expect(pages.every((page) => languageCodes.includes(page.languageCode))).toBe(true)
    })

    test('every page has a non-empty `permalinks` array', async () => {
      const brokenPages = pages.filter(
        (page) => !Array.isArray(page.permalinks) || page.permalinks.length === 0,
      )

      const expectation = JSON.stringify(
        brokenPages.map((page) => page.fullPath),
        null,
        2,
      )
      expect(brokenPages.length, expectation).toBe(0)
    })

    test('redirect_from routes are unique across English pages', () => {
      const englishPages = chain(pages)
        .filter(['languageCode', 'en'])
        .filter('redirect_from')
        .map((page) => pick(page, ['redirect_from', 'applicableVersions', 'fullPath']))
        .value()

      // Map from redirect path to Set of file paths
      const redirectToFiles = new Map<string, Set<string>>()
      const versionedRedirects: Array<{ path: string; file: string }> = []

      // Page objects have dynamic properties from chain/lodash that aren't fully typed
      for (const page of englishPages) {
        const pageObj = page as Record<string, unknown>
        for (const redirect of pageObj.redirect_from as string[]) {
          for (const version of pageObj.applicableVersions as string[]) {
            const versioned = removeFPTFromPath(path.posix.join('/', version, redirect))
            versionedRedirects.push({ path: versioned, file: pageObj.fullPath as string })
            if (!redirectToFiles.has(versioned)) {
              redirectToFiles.set(versioned, new Set<string>())
            }
            redirectToFiles.get(versioned)!.add(pageObj.fullPath as string)
          }
        }
      }

      // Only consider as duplicate if more than one unique file defines the same redirect
      const duplicates = Array.from(redirectToFiles.entries())
        .filter(([, files]) => files.size > 1)
        .map(([redirectPath]) => redirectPath)

      // Build a detailed message with sources for each duplicate
      const message = `Found ${duplicates.length} duplicate redirect_from path${duplicates.length === 1 ? '' : 's'}.
        Ensure that you don't define the same path more than once in the redirect_from property in a single file and across all English files.
        You may also receive this error if you have defined the same children property more than once.\n${duplicates
          .map((dup) => {
            const files = Array.from(redirectToFiles.get(dup) || [])
            return `${dup}\n  Defined in:\n    ${files.join('\n    ')}`
          })
          .join('\n\n')}`
      expect(duplicates.length, message).toBe(0)
    })

    test('every English page has a filename that matches its slugified title or shortTitle', async () => {
      const nonMatches = pages
        .filter((page) => {
          slugger.reset()
          return (
            page.languageCode === 'en' && // only check English
            !page.relativePath.includes('index.md') && // ignore TOCs
            // Page class has dynamic frontmatter properties like 'allowTitleToDifferFromFilename' not in type definition
            !(page as Record<string, unknown>).allowTitleToDifferFromFilename && // ignore docs with override
            slugger.slug(decode(page.title)) !== path.basename(page.relativePath, '.md') &&
            slugger.slug(decode(page.shortTitle || '')) !== path.basename(page.relativePath, '.md')
          )
        })
        // make the output easier to read
        .map((page) => {
          return JSON.stringify(
            {
              file: path.basename(page.relativePath),
              title: page.title,
              path: page.fullPath,
            },
            null,
            2,
          )
        })

      const message = `
  Found ${nonMatches.length} ${
    nonMatches.length === 1 ? 'file' : 'files'
  } that do not match their slugified titles.\n
  ${nonMatches.join('\n')}\n
  To fix, run: npm run-script update-filepaths --paths [FILEPATHS]\n\n`

      expect(nonMatches.length, message).toBe(0)
    })

    test('every page has valid frontmatter', async () => {
      const frontmatterErrors = chain(pages)
        // .filter(page => page.languageCode === 'en')
        // Page class has dynamic error properties like 'frontmatterErrors' not in type definition
        .map((page) => (page as Record<string, unknown>).frontmatterErrors)
        .filter(Boolean)
        .flatten()
        .value()

      const failureMessage = `${JSON.stringify(frontmatterErrors, null, 2)}\n\n${chain(
        frontmatterErrors,
      )
        .map('filepath')
        .join('\n')
        .value()}`

      expect(frontmatterErrors.length, failureMessage).toBe(0)
    })

    test('every page has valid Liquid templating', async () => {
      const liquidErrors: Array<{ filename: string; error: string }> = []

      for (const page of pages) {
        // Page class has dynamic properties like 'raw' markdown not in type definition
        const markdown = (page as Record<string, unknown>).raw as string
        if (!patterns.hasLiquid.test(markdown)) continue
        try {
          await liquid.parse(markdown)
        } catch (error) {
          liquidErrors.push({
            filename: page.fullPath,
            error: (error as Error).message,
          })
        }
      }

      const failureMessage = JSON.stringify(liquidErrors, null, 2)
      expect(liquidErrors.length, failureMessage).toBe(0)
    })
  })
})