@knpkv/confluence-to-markdown 0.6.0 → 0.7.0

package/test/commandHarness.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import type { PageId } from "../src/Brand.js"
+import { makeFetchCommand } from "../src/commands/fetch.js"
+import { ConfluenceClient } from "../src/ConfluenceClient.js"
+import type { PageResponse } from "../src/Schemas.js"
+import { CommandHarnessLayer, runConfluenceCommand } from "./commandHarness.js"
+
+const page: PageResponse = {
+  id: "2333334354",
+  title: "Harness Page",
+  version: { number: 1 },
+  body: {
+    atlas_doc_format: {
+      representation: "atlas_doc_format",
+      value: JSON.stringify({ type: "doc", version: 1, content: [] })
+    }
+  }
+}
+
+const FetchClientLayer = Layer.succeed(
+  ConfluenceClient,
+  ConfluenceClient.of({
+    getPage: (pageId: PageId) =>
+      pageId === "2333334354"
+        ? Effect.succeed(page)
+        : Effect.die(`unexpected page ID: ${pageId}`),
+    getChildren: () => Effect.die("unused"),
+    getAllChildren: () => Effect.die("unused"),
+    createPage: () => Effect.die("unused"),
+    updatePage: () => Effect.die("unused"),
+    deletePage: () => Effect.die("unused"),
+    getPageVersions: () => Effect.die("unused"),
+    getUser: () => Effect.die("unused"),
+    getSpaceId: () => Effect.die("unused"),
+    setEditorVersion: () => Effect.die("unused")
+  })
+)
+
+describe("command harness", () => {
+  it.effect("runs fetch through the root command without calling GitService", () =>
+    Effect.gen(function*() {
+      const gitCalls = yield* Ref.make(0)
+      const stdout = yield* Ref.make("")
+      const fetch = makeFetchCommand({ makeClientLayer: () => FetchClientLayer })
+
+      const exit = yield* runConfluenceCommand([
+        "fetch",
+        "--url",
+        "https://example.atlassian.net/wiki/pages/2333334354"
+      ], { fetch }).pipe(Effect.provide(CommandHarnessLayer({ gitCalls, stdout })))
+      const calls = yield* Ref.get(gitCalls)
+      const output = yield* Ref.get(stdout)
+
+      expect(exit._tag).toBe("Success")
+      expect(output).toBe("# Harness Page\n")
+      expect(calls).toBe(0)
+    }))
+
+  it.effect("rejects conflicting clone URL input before calling GitService", () =>
+    Effect.gen(function*() {
+      const gitCalls = yield* Ref.make(0)
+      const stdout = yield* Ref.make("")
+
+      const exit = yield* runConfluenceCommand([
+        "clone",
+        "--url",
+        "https://example.atlassian.net/wiki/pages/2333334354",
+        "--base-url",
+        "https://example.atlassian.net"
+      ]).pipe(Effect.provide(CommandHarnessLayer({ gitCalls, stdout })))
+      const calls = yield* Ref.get(gitCalls)
+
+      expect(exit._tag).toBe("Failure")
+      expect(calls).toBe(0)
+    }))
+})

package/test/commandHarness.ts

@@ -0,0 +1,147 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import * as Terminal from "effect/Terminal"
+import { Command } from "effect/unstable/cli"
+import type { PageId } from "../src/Brand.js"
+import type { ConfluenceCommandOptions } from "../src/commands/root.js"
+import { makeConfluenceCommand } from "../src/commands/root.js"
+import { ConfluenceAuth } from "../src/ConfluenceAuth.js"
+import { ConfluenceClient } from "../src/ConfluenceClient.js"
+import { layerFromValues as ConfluenceConfigLayerFromValues } from "../src/ConfluenceConfig.js"
+import { GitService } from "../src/GitService.js"
+import { MarkdownConverter } from "../src/MarkdownConverter.js"
+import { SyncEngine } from "../src/SyncEngine.js"
+
+const notCalled = (calls: Ref.Ref<number>) =>
+  Ref.update(calls, (count) => count + 1).pipe(
+    Effect.flatMap(() => Effect.die("GitService should not be called"))
+  )
+
+export const GitShouldNotBeCalledLayer = (calls: Ref.Ref<number>) =>
+  Layer.succeed(
+    GitService,
+    GitService.of({
+      validateGit: () => notCalled(calls),
+      init: () => notCalled(calls),
+      isInitialized: () => notCalled(calls),
+      status: () => notCalled(calls),
+      commit: () => notCalled(calls),
+      log: () => notCalled(calls),
+      diff: () => notCalled(calls),
+      addAll: () => notCalled(calls),
+      hasConflicts: () => notCalled(calls),
+      mergeContinue: () => notCalled(calls),
+      syncFromDocs: () => notCalled(calls),
+      syncToDocs: () => notCalled(calls),
+      getHead: () => notCalled(calls),
+      getCurrentBranch: () => notCalled(calls),
+      createBranch: () => notCalled(calls),
+      checkout: () => notCalled(calls),
+      reset: () => notCalled(calls),
+      deleteBranch: () => notCalled(calls),
+      getParent: () => notCalled(calls),
+      cherryPick: () => notCalled(calls),
+      getChangedFiles: () => notCalled(calls),
+      showFile: () => notCalled(calls),
+      amend: () => notCalled(calls),
+      logRange: () => notCalled(calls),
+      branchExists: () => notCalled(calls),
+      updateBranch: () => notCalled(calls),
+      merge: () => notCalled(calls),
+      getDeletedFiles: () => notCalled(calls),
+      getFileContentAt: () => notCalled(calls)
+    })
+  )
+
+export interface CommandHarnessRefs {
+  readonly gitCalls: Ref.Ref<number>
+  readonly stdout: Ref.Ref<string>
+}
+
+const CaptureTerminalLayer = (stdout: Ref.Ref<string>) =>
+  Layer.succeed(
+    Terminal.Terminal,
+    Terminal.Terminal.of({
+      columns: Effect.succeed(80),
+      rows: Effect.succeed(24),
+      readInput: Effect.die("readInput should not be called"),
+      readLine: Effect.die("readLine should not be called"),
+      display: (text) => Ref.update(stdout, (output) => output + text)
+    })
+  )
+
+const AuthLayer = Layer.succeed(
+  ConfluenceAuth,
+  ConfluenceAuth.of({
+    configure: () => Effect.void,
+    isConfigured: () => Effect.succeed(true),
+    login: () => Effect.void,
+    logout: () => Effect.void,
+    getAccessToken: () => Effect.succeed("access-token"),
+    getCloudId: () => Effect.succeed("cloud-id"),
+    getCurrentUser: () => Effect.succeed(null),
+    isLoggedIn: () => Effect.succeed(true)
+  })
+)
+
+const SyncEngineLayer = Layer.succeed(
+  SyncEngine,
+  SyncEngine.of({
+    pull: () => Effect.die("SyncEngine should not be called"),
+    push: () => Effect.die("SyncEngine should not be called"),
+    status: () => Effect.die("SyncEngine should not be called")
+  })
+)
+
+const MarkdownConverterLayer = Layer.succeed(
+  MarkdownConverter,
+  MarkdownConverter.of({
+    adfToMarkdown: () => Effect.succeed("# Harness Page\n"),
+    markdownToAdf: () => Effect.die("markdownToAdf should not be called")
+  })
+)
+
+const DummyConfluenceClientLayer = Layer.succeed(
+  ConfluenceClient,
+  ConfluenceClient.of({
+    getPage: () => Effect.die("Use an injected fetch client layer in command tests"),
+    getChildren: () => Effect.die("ConfluenceClient should not be called"),
+    getAllChildren: () => Effect.die("ConfluenceClient should not be called"),
+    createPage: () => Effect.die("ConfluenceClient should not be called"),
+    updatePage: () => Effect.die("ConfluenceClient should not be called"),
+    deletePage: () => Effect.die("ConfluenceClient should not be called"),
+    getPageVersions: () => Effect.die("ConfluenceClient should not be called"),
+    getUser: () => Effect.die("ConfluenceClient should not be called"),
+    getSpaceId: () => Effect.die("ConfluenceClient should not be called"),
+    setEditorVersion: () => Effect.die("ConfluenceClient should not be called")
+  })
+)
+
+const ConfigLayer = ConfluenceConfigLayerFromValues({
+  rootPageId: "dummy" as PageId,
+  baseUrl: "https://dummy.atlassian.net",
+  docsPath: ".confluence/docs",
+  excludePatterns: [],
+  saveSource: false,
+  trackedPaths: ["**/*.md"]
+})
+
+export const CommandHarnessLayer = (refs: CommandHarnessRefs) =>
+  Layer.mergeAll(
+    AuthLayer,
+    GitShouldNotBeCalledLayer(refs.gitCalls),
+    SyncEngineLayer,
+    MarkdownConverterLayer,
+    DummyConfluenceClientLayer,
+    ConfigLayer,
+    CaptureTerminalLayer(refs.stdout)
+  )
+
+export const runConfluenceCommand = (
+  args: ReadonlyArray<string>,
+  options: ConfluenceCommandOptions = {}
+) => {
+  const cli = Command.runWith(makeConfluenceCommand(options), { version: "0.0.0-test" })
+  return cli(args).pipe(Effect.exit)
+}

package/test/fetch.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type { PageId } from "../src/Brand.js"
+import { fetchPageMarkdown } from "../src/commands/fetch.js"
+import { ConfluenceClient } from "../src/ConfluenceClient.js"
+import { MarkdownConverter } from "../src/MarkdownConverter.js"
+import type { PageResponse } from "../src/Schemas.js"
+
+const page: PageResponse = {
+  id: "2333334354",
+  title: "Fetched Page",
+  version: { number: 7 },
+  body: {
+    atlas_doc_format: {
+      representation: "atlas_doc_format",
+      value: JSON.stringify({ type: "doc", version: 1, content: [] })
+    }
+  }
+}
+
+const TestLayer = Layer.mergeAll(
+  Layer.succeed(
+    ConfluenceClient,
+    ConfluenceClient.of({
+      getPage: () => Effect.succeed(page),
+      getChildren: () => Effect.die("unused"),
+      getAllChildren: () => Effect.die("unused"),
+      createPage: () => Effect.die("unused"),
+      updatePage: () => Effect.die("unused"),
+      deletePage: () => Effect.die("unused"),
+      getPageVersions: () => Effect.die("unused"),
+      getUser: () => Effect.die("unused"),
+      getSpaceId: () => Effect.die("unused"),
+      setEditorVersion: () => Effect.die("unused")
+    })
+  ),
+  Layer.succeed(
+    MarkdownConverter,
+    MarkdownConverter.of({
+      adfToMarkdown: () => Effect.succeed("# Fetched Page\n\n<!-- adf:panel attrs={} -->\n\nBody\n"),
+      markdownToAdf: () => Effect.die("unused")
+    })
+  )
+)
+
+describe("fetchPageMarkdown", () => {
+  it.effect("returns preserving markdown by default", () =>
+    Effect.gen(function*() {
+      const markdown = yield* fetchPageMarkdown("2333334354" as PageId, { cleanMarkdown: false })
+
+      expect(markdown).toContain("<!-- adf:panel attrs={} -->")
+    }).pipe(Effect.provide(TestLayer)))
+
+  it.effect("can return clean markdown", () =>
+    Effect.gen(function*() {
+      const markdown = yield* fetchPageMarkdown("2333334354" as PageId, { cleanMarkdown: true })
+
+      expect(markdown).toBe("# Fetched Page\n\nBody\n")
+    }).pipe(Effect.provide(TestLayer)))
+})

package/test/frontmatter.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import { ContentHash, PageId } from "../src/Brand.js"
+import { parseMarkdown, serializeMarkdown, serializeNewPageMarkdown } from "../src/internal/frontmatter.js"
+
+describe("frontmatter serialization", () => {
+  it.effect("serializes existing page frontmatter without gray-matter safeDump", () =>
+    Effect.gen(function*() {
+      const serialized = serializeMarkdown(
+        {
+          pageId: PageId("123"),
+          version: 7,
+          title: "A page",
+          updated: new Date("2026-06-24T10:00:00.000Z"),
+          parentId: PageId("456"),
+          contentHash: ContentHash("a".repeat(64))
+        },
+        "Body\n"
+      )
+
+      expect(serialized).toContain("pageId: '123'")
+      expect(serialized).toContain("version: 7")
+      expect(serialized).toContain("updated: '2026-06-24T10:00:00.000Z'")
+
+      const parsed = yield* parseMarkdown("page.md", serialized)
+      expect(parsed.isNew).toBe(false)
+      expect(parsed.content).toBe("Body")
+    }))
+
+  it("serializes new page frontmatter", () => {
+    const serialized = serializeNewPageMarkdown(
+      {
+        title: "New page",
+        parentId: PageId("456")
+      },
+      "Draft"
+    )
+
+    expect(serialized).toBe("---\ntitle: New page\nparentId: '456'\n---\nDraft\n")
+  })
+})