Markdown 콘텐츠 로더 테스트하기: Deno 임시 파일로 정상·초안·오류 검증하기

const post = await getPost(
  "fresh-markdown-blog",
);

const POSTS_DIR = "./content/posts";

getPost("hello");
getPost("hello", testDirectory);

export async function getPost(
  slug: string,
  postsDir = POSTS_DIR,
): Promise<Post | null> {
  let source: string;

  try {
    source = await Deno.readTextFile(
      `${postsDir}/${slug}.md`,
    );
  } catch (error) {
    if (error instanceof Deno.errors.NotFound) {
      return null;
    }

    throw error;
  }

  const { attrs, body } = extractYaml<PostMeta>(
    source,
  );

  if (attrs.draft) {
    return null;
  }

  return {
    slug,
    meta: attrs,
    html: render(body),
    readingTime: estimateReadingTime(body),
  };
}

export async function getPosts(
  postsDir = POSTS_DIR,
): Promise<PostSummary[]> {
  const posts: PostSummary[] = [];

  for await (
    const entry of Deno.readDir(postsDir)
  ) {
    if (
      !entry.isFile ||
      !entry.name.endsWith(".md")
    ) {
      continue;
    }

    const slug = entry.name.replace(
      /\.md$/,
      "",
    );

    const source = await Deno.readTextFile(
      `${postsDir}/${entry.name}`,
    );

    const { attrs } = extractYaml<PostMeta>(
      source,
    );

    if (attrs.draft) {
      continue;
    }

    posts.push({
      slug,
      meta: attrs,
    });
  }

  return posts.sort(comparePostsByNewest);
}

export async function getSeriesPosts(
  postsDir = POSTS_DIR,
): Promise<PostSummary[]> {
  return sortSeriesPosts(
    await getPosts(postsDir),
  );
}

import {
  assert,
  assertEquals,
  assertRejects,
} from "jsr:@std/assert@1.0.19";

import {
  getPost,
  getPosts,
  getSeriesPosts,
} from "./posts.ts";

function markdown(
  overrides: Record<string, unknown> = {},
  body = "## Test heading\n\nA **saved** paragraph.",
) {
  const meta = {
    title: "Fixture post",
    description:
      "콘텐츠 로더 테스트용 글입니다.",
    date: "2026-11-04",
    category: "Deno",
    tags: ["Deno", "Testing"],
    draft: false,
    ...overrides,
  };

  return `---
${JSON.stringify(meta)}
---

${body}`;
}

async function withPosts(
  files: Record<string, string>,
  run: (dir: string) => Promise<void>,
) {
  await Deno.mkdir("./.test-tmp", {
    recursive: true,
  });

  const dir = await Deno.makeTempDir({
    dir: "./.test-tmp",
    prefix: "posts-",
  });

  try {
    for (
      const [name, source] of Object.entries(
        files,
      )
    ) {
      await Deno.writeTextFile(
        `${dir}/${name}`,
        source,
      );
    }

    await run(dir);
  } finally {
    await Deno.remove(dir, {
      recursive: true,
    });
  }
}

Deno.test(
  "getPost: 메타데이터와 HTML을 반환한다",
  async () => {
    await withPosts(
      {
        "hello.md": markdown(),
      },
      async (dir) => {
        const post = await getPost(
          "hello",
          dir,
        );

        assert(post);

        assertEquals(
          post.slug,
          "hello",
        );

        assertEquals(
          post.meta.title,
          "Fixture post",
        );

        assertEquals(
          post.meta.date,
          "2026-11-04",
        );

        assertEquals(
          post.meta.tags,
          ["Deno", "Testing"],
        );

        assert(
          post.html.includes(
            "<strong>saved</strong>",
          ),
        );

        assert(
          !post.html.includes(
            "콘텐츠 로더 테스트용 글입니다.",
          ),
        );
      },
    );
  },
);

Deno.test(
  "getPost: 없는 글은 null이다",
  async () => {
    await withPosts({}, async (dir) => {
      assertEquals(
        await getPost("missing", dir),
        null,
      );
    });
  },
);

Deno.test(
  "getPost: 초안은 null이다",
  async () => {
    await withPosts(
      {
        "draft.md": markdown({
          draft: true,
        }),
      },
      async (dir) => {
        assertEquals(
          await getPost("draft", dir),
          null,
        );
      },
    );
  },
);

Deno.test(
  "깨진 YAML은 상세와 목록에서 예외로 전달된다",
  async () => {
    await withPosts(
      {
        "broken.md":
          "---\ntitle: [broken\n---\nBody",
      },
      async (dir) => {
        await assertRejects(
          () => getPost("broken", dir),
        );

        await assertRejects(
          () => getPosts(dir),
        );
      },
    );
  },
);

Deno.test({
  name:
    "getPost: 읽기 권한 오류를 null로 숨기지 않는다",

  permissions: {
    read: false,
    write: ["./.test-tmp"],
  },

  async fn() {
    await withPosts(
      {
        "hello.md": markdown(),
      },
      async (dir) => {
        await assertRejects(
          () => getPost("hello", dir),
          Deno.errors.NotCapable,
        );
      },
    );
  },
});

Deno.test(
  "getPosts: 초안, 다른 확장자, 디렉터리를 제외한다",
  async () => {
    await withPosts(
      {
        "published.md": markdown(),

        "draft.md": markdown({
          draft: true,
        }),

        "notes.txt": "메모",
      },
      async (dir) => {
        await Deno.mkdir(
          `${dir}/nested.md`,
        );

        const posts = await getPosts(dir);

        assertEquals(
          posts.map((post) => post.slug),
          ["published"],
        );
      },
    );
  },
);

Deno.test(
  "파일 메타데이터를 최신순과 연재순에 연결한다",
  async () => {
    await withPosts(
      {
        "first.md": markdown({
          order: 1,
        }),

        "second.md": markdown({
          order: 2,
        }),

        "third.md": markdown({
          date: "2026-11-05",
          order: 3,
        }),

        "standalone.md": markdown({
          date: "2026-11-06",
        }),
      },
      async (dir) => {
        const newest = await getPosts(dir);

        assertEquals(
          newest.map((post) => post.slug),
          [
            "standalone",
            "third",
            "second",
            "first",
          ],
        );

        const series = await getSeriesPosts(
          dir,
        );

        assertEquals(
          series.map((post) => post.slug),
          [
            "first",
            "second",
            "third",
          ],
        );
      },
    );
  },
);

Deno.test(
  "getPosts: 빈 디렉터리는 빈 목록이다",
  async () => {
    await withPosts({}, async (dir) => {
      assertEquals(
        await getPosts(dir),
        [],
      );
    });
  },
);

markdown({ draft: true });
markdown({ order: 2 });

const dir = await Deno.makeTempDir({
  dir: "./.test-tmp",
  prefix: "posts-",
});

try {
  // 파일 작성과 테스트
} finally {
  await Deno.remove(dir, {
    recursive: true,
  });
}

assert(
  post.html.includes(
    "<strong>saved</strong>",
  ),
);

assert(
  !post.html.includes(
    "콘텐츠 로더 테스트용 글입니다.",
  ),
);

await Deno.mkdir(
  `${dir}/nested.md`,
);

permissions: {
  read: false,
  write: ["./.test-tmp"],
}

await assertRejects(
  () => getPost("hello", dir),
  Deno.errors.NotCapable,
);

permissions: {
  read: false,
}

try {
  // 파일 읽기
  // Front Matter 파싱
  // Markdown 렌더링
} catch {
  return null;
}