@filen/sync 0.2.1 → 0.3.2

package/tests/unit/n-unit.test.ts

@@ -0,0 +1,632 @@
+import { describe, it, expect } from "vitest"
+import {
+	isValidPath,
+	isPathOverMaxLength,
+	isNameOverMaxLength,
+	convertTimestampToMs,
+	normalizeUTime,
+	normalizeLastModifiedMsForComparison,
+	pathIncludesDotFile,
+	isNameIgnoredByDefault,
+	isRelativePathIgnoredByDefault,
+	isAbsolutePathIgnoredByDefault,
+	serializeError,
+	deserializeError,
+	fastHash,
+	tryingToSyncDesktop,
+	replacePathStartWithFromAndTo
+} from "../../src/utils"
+import { Semaphore } from "../../src/semaphore"
+import { Logger } from "../../src/lib/logger"
+
+/**
+ * Category N — unit tests (behavioral spec §N).
+ *
+ * Pure-function and small-class coverage that complements the scenario suite: platform-specific
+ * path/length validation (via stubbed `process.platform`), time normalization, default-ignore
+ * helpers, error (de)serialization, hashing, the desktop guard, the Semaphore primitive and the
+ * disabled-Logger path. Every expectation here was verified against the real implementation.
+ */
+
+/**
+ * Run `fn` with `process.platform` temporarily stubbed. `process.platform` is a non-writable but
+ * configurable property, so it must be replaced via `defineProperty` and restored from its original
+ * descriptor.
+ */
+function withPlatform(platform: NodeJS.Platform, fn: () => void): void {
+	const original = Object.getOwnPropertyDescriptor(process, "platform")
+
+	Object.defineProperty(process, "platform", { value: platform, configurable: true })
+
+	try {
+		fn()
+	} finally {
+		if (original) {
+			Object.defineProperty(process, "platform", original)
+		}
+	}
+}
+
+/**
+ * Run `fn` with a `process.env` key temporarily overridden, restoring (or deleting) it afterwards.
+ */
+function withEnv(key: string, value: string, fn: () => void): void {
+	const original = process.env[key]
+
+	process.env[key] = value
+
+	try {
+		fn()
+	} finally {
+		if (original === undefined) {
+			delete process.env[key]
+		} else {
+			process.env[key] = original
+		}
+	}
+}
+
+/**
+ * Resolve on the next macrotask tick so all pending promise microtasks have drained — used to assert
+ * that a Semaphore waiter has NOT resolved.
+ */
+function tick(): Promise<void> {
+	return new Promise<void>(resolve => setTimeout(resolve, 0))
+}
+
+describe("Category N — utils.isValidPath (win32)", () => {
+	it("accepts an ordinary drive-rooted path", () => {
+		withPlatform("win32", () => {
+			expect(isValidPath("C:/Users/me/Documents/report.txt")).toBe(true)
+		})
+	})
+
+	it("normalizes backslashes before validating", () => {
+		withPlatform("win32", () => {
+			expect(isValidPath("C:\\Users\\me\\file.txt")).toBe(true)
+		})
+	})
+
+	it("rejects each Windows illegal char in a component", () => {
+		withPlatform("win32", () => {
+			for (const bad of ["<", ">", "\"", "|", "?", "*"]) {
+				expect(isValidPath(`C:/folder/in${bad}valid.txt`)).toBe(false)
+			}
+		})
+	})
+
+	it("rejects a colon outside the drive-letter position", () => {
+		withPlatform("win32", () => {
+			expect(isValidPath("C:/a:b/c")).toBe(false)
+		})
+	})
+
+	it("rejects reserved device names case-insensitively", () => {
+		withPlatform("win32", () => {
+			for (const name of ["con", "CON", "Prn", "aux", "NUL", "com1", "LPT9"]) {
+				expect(isValidPath(`C:/folder/${name}`)).toBe(false)
+			}
+		})
+	})
+
+	it("rejects a reserved name even when it carries an extension", () => {
+		withPlatform("win32", () => {
+			expect(isValidPath("C:/folder/con.txt")).toBe(false)
+			expect(isValidPath("C:/folder/com1.log")).toBe(false)
+		})
+	})
+
+	it("rejects a component that ends with a dot or a space (Windows strips them)", () => {
+		withPlatform("win32", () => {
+			// A name Windows silently strips would be created under a DIFFERENT name than recorded — an
+			// endless re-sync/duplication loop — so it must be reported invalid and ignored. (M5)
+			expect(isValidPath("C:/folder/report.")).toBe(false)
+			expect(isValidPath("C:/folder/report ")).toBe(false)
+			expect(isValidPath("C:/folder/report...")).toBe(false)
+			expect(isValidPath("C:/folder/report.  ")).toBe(false)
+			// An intermediate DIRECTORY component is just as fatal as the leaf.
+			expect(isValidPath("C:/folder./report.txt")).toBe(false)
+			expect(isValidPath("C:/folder /report.txt")).toBe(false)
+		})
+	})
+
+	it("rejects an all-dots component", () => {
+		withPlatform("win32", () => {
+			expect(isValidPath("C:/folder/...")).toBe(false)
+			expect(isValidPath("C:/folder/..")).toBe(false)
+			expect(isValidPath("C:/folder/.")).toBe(false)
+		})
+	})
+
+	it("still accepts a leading-dot (hidden) name and interior dots", () => {
+		withPlatform("win32", () => {
+			// The fix strips only TRAILING dots/spaces; a leading dot (hidden files) and interior dots are fine.
+			expect(isValidPath("C:/folder/.gitignore")).toBe(true)
+			expect(isValidPath("C:/folder/my.file.txt")).toBe(true)
+			expect(isValidPath("C:/folder/.config/app.json")).toBe(true)
+		})
+	})
+})
+
+describe("Category N — utils.isValidPath (darwin)", () => {
+	it("accepts an ordinary absolute path", () => {
+		withPlatform("darwin", () => {
+			expect(isValidPath("/Users/me/Documents/file.txt")).toBe(true)
+		})
+	})
+
+	it("rejects a colon and a NUL byte", () => {
+		withPlatform("darwin", () => {
+			expect(isValidPath("/Users/me/foo:bar.txt")).toBe(false)
+			expect(isValidPath("/Users/me/foo\x00bar")).toBe(false)
+		})
+	})
+
+	it("permits chars that are illegal on Windows but legal on macOS", () => {
+		withPlatform("darwin", () => {
+			expect(isValidPath("/Users/me/a<b>c|d?e*.txt")).toBe(true)
+		})
+	})
+
+	it("does not treat Windows reserved names as invalid", () => {
+		withPlatform("darwin", () => {
+			expect(isValidPath("/Users/me/con")).toBe(true)
+		})
+	})
+
+	it("permits trailing dots and spaces (legal on macOS, only stripped on Windows)", () => {
+		withPlatform("darwin", () => {
+			// The trailing-dot/space rejection is a Windows-only quirk; macOS represents these names fine, so
+			// the M5 guard must not bleed into the darwin branch.
+			expect(isValidPath("/Users/me/report.")).toBe(true)
+			expect(isValidPath("/Users/me/report ")).toBe(true)
+		})
+	})
+})
+
+describe("Category N — utils.isValidPath (linux)", () => {
+	it("accepts an ordinary absolute path", () => {
+		withPlatform("linux", () => {
+			expect(isValidPath("/home/me/Documents/file.txt")).toBe(true)
+		})
+	})
+
+	it("permits a colon (only NUL is illegal on linux)", () => {
+		withPlatform("linux", () => {
+			expect(isValidPath("/home/me/foo:bar")).toBe(true)
+			expect(isValidPath("/home/me/a<b>:c")).toBe(true)
+		})
+	})
+
+	it("rejects a NUL byte", () => {
+		withPlatform("linux", () => {
+			expect(isValidPath("/home/me/foo\x00bar")).toBe(false)
+		})
+	})
+})
+
+describe("Category N — utils.isValidPath (unknown platform)", () => {
+	it("rejects everything on an unrecognized platform (default branch)", () => {
+		withPlatform("freebsd", () => {
+			expect(isValidPath("/perfectly/valid/path.txt")).toBe(false)
+		})
+	})
+})
+
+describe("Category N — utils.isPathOverMaxLength / isNameOverMaxLength", () => {
+	it("uses a 4096 path limit on linux (length + 1 > limit)", () => {
+		withPlatform("linux", () => {
+			expect(isPathOverMaxLength("a".repeat(4095))).toBe(false)
+			expect(isPathOverMaxLength("a".repeat(4096))).toBe(true)
+		})
+	})
+
+	it("uses a 1024 path limit on darwin", () => {
+		withPlatform("darwin", () => {
+			expect(isPathOverMaxLength("a".repeat(1023))).toBe(false)
+			expect(isPathOverMaxLength("a".repeat(1024))).toBe(true)
+		})
+	})
+
+	it("uses a 512 path limit on win32", () => {
+		withPlatform("win32", () => {
+			expect(isPathOverMaxLength("a".repeat(511))).toBe(false)
+			expect(isPathOverMaxLength("a".repeat(512))).toBe(true)
+		})
+	})
+
+	it("falls back to a 512 path limit on an unknown platform", () => {
+		withPlatform("freebsd", () => {
+			expect(isPathOverMaxLength("a".repeat(511))).toBe(false)
+			expect(isPathOverMaxLength("a".repeat(512))).toBe(true)
+		})
+	})
+
+	it("uses a 255 name limit on every platform", () => {
+		for (const platform of ["linux", "darwin", "win32", "freebsd"] as const) {
+			withPlatform(platform, () => {
+				expect(isNameOverMaxLength("a".repeat(254))).toBe(false)
+				expect(isNameOverMaxLength("a".repeat(255))).toBe(true)
+			})
+		}
+	})
+
+	// Multibyte semantics. "あ" is 1 UTF-16 code unit but 3 UTF-8 bytes. Linux NAME_MAX/PATH_MAX are BYTE
+	// limits, so the guard must count UTF-8 bytes there; macOS/Windows count UTF-16 code units for NAMES
+	// (verified empirically on darwin: 255 units / 765 bytes is accepted, 256 units rejected) but macOS
+	// PATH_MAX is a BYTE limit (a 473-unit / 1273-byte path is ENAMETOOLONG). String.length undercounting a
+	// multibyte name on linux is the bug: it would pass the guard and then fail at the filesystem forever.
+	const NAME_100_CJK = "あ".repeat(100) // 100 UTF-16 units, 300 UTF-8 bytes
+
+	it("counts NAME length in UTF-8 BYTES on linux (a 300-byte / 100-unit name is over the 255 limit)", () => {
+		withPlatform("linux", () => {
+			expect(isNameOverMaxLength(NAME_100_CJK)).toBe(true)
+			// A name comfortably under 255 BYTES is fine (80 CJK = 240 bytes).
+			expect(isNameOverMaxLength("あ".repeat(80))).toBe(false)
+		})
+	})
+
+	it("counts NAME length in UTF-16 CODE UNITS on darwin and win32 (a 300-byte / 100-unit name is fine)", () => {
+		for (const platform of ["darwin", "win32"] as const) {
+			withPlatform(platform, () => {
+				expect(isNameOverMaxLength(NAME_100_CJK)).toBe(false)
+				// 256 UTF-16 units is over regardless of byte length.
+				expect(isNameOverMaxLength("あ".repeat(256))).toBe(true)
+			})
+		}
+	})
+
+	it("counts PATH length in UTF-8 BYTES on linux and darwin, UTF-16 units on win32", () => {
+		// 400 CJK = 400 UTF-16 units, 1200 UTF-8 bytes.
+		const PATH_400_CJK = "あ".repeat(400)
+
+		// darwin: 1200 bytes > 1024 byte limit → over; the 400-unit count would be UNDER and wrongly allow it.
+		withPlatform("darwin", () => expect(isPathOverMaxLength(PATH_400_CJK)).toBe(true))
+		// linux: 1200 bytes < 4096 → fine; but 1400 CJK = 4200 bytes > 4096 → over (4096 is a BYTE limit).
+		withPlatform("linux", () => {
+			expect(isPathOverMaxLength(PATH_400_CJK)).toBe(false)
+			expect(isPathOverMaxLength("あ".repeat(1400))).toBe(true)
+		})
+		// win32: paths are UTF-16 code units — 400 units < 512 → fine even though it is 1200 bytes.
+		withPlatform("win32", () => expect(isPathOverMaxLength(PATH_400_CJK)).toBe(false))
+	})
+})
+
+describe("Category N — utils.convertTimestampToMs", () => {
+	it("passes a value already in milliseconds through unchanged", () => {
+		const nowMs = Date.now()
+
+		expect(convertTimestampToMs(nowMs)).toBe(nowMs)
+		// Fixed golden well above the seconds/ms crossover.
+		expect(convertTimestampToMs(1_700_000_000_000)).toBe(1_700_000_000_000)
+	})
+
+	it("multiplies a value expressed in seconds by 1000", () => {
+		const nowSec = Math.floor(Date.now() / 1000)
+
+		expect(convertTimestampToMs(nowSec)).toBe(nowSec * 1000)
+		// Fixed golden well below the crossover (year 2001 in seconds).
+		expect(convertTimestampToMs(1_000_000_000)).toBe(1_000_000_000_000)
+	})
+})
+
+describe("Category N — utils.normalizeUTime", () => {
+	it("returns integers unchanged", () => {
+		expect(normalizeUTime(1234)).toBe(1234)
+		expect(normalizeUTime(0)).toBe(0)
+	})
+
+	it("floors non-integers (towards negative infinity, not truncation)", () => {
+		expect(normalizeUTime(1234.99)).toBe(1234)
+		expect(normalizeUTime(-3.2)).toBe(-4)
+	})
+})
+
+describe("Category N — utils.normalizeLastModifiedMsForComparison", () => {
+	it("floors milliseconds down to whole seconds", () => {
+		expect(normalizeLastModifiedMsForComparison(1500)).toBe(1)
+		expect(normalizeLastModifiedMsForComparison(1999)).toBe(1)
+		expect(normalizeLastModifiedMsForComparison(2000)).toBe(2)
+		expect(normalizeLastModifiedMsForComparison(0)).toBe(0)
+	})
+
+	it("collapses two times within the same second to the same value", () => {
+		expect(normalizeLastModifiedMsForComparison(1000)).toBe(normalizeLastModifiedMsForComparison(1999))
+	})
+})
+
+describe("Category N — utils.pathIncludesDotFile", () => {
+	it("detects a dot-prefixed component at any depth", () => {
+		expect(pathIncludesDotFile("/a/.b/c")).toBe(true)
+		expect(pathIncludesDotFile("/a/b/.c/d")).toBe(true)
+		expect(pathIncludesDotFile("/a/b/c/.last")).toBe(true)
+		expect(pathIncludesDotFile(".hidden")).toBe(true)
+	})
+
+	it("returns false when no component is dot-prefixed", () => {
+		expect(pathIncludesDotFile("/a/b/c")).toBe(false)
+		// A dot inside a component (an extension) is not a dot file.
+		expect(pathIncludesDotFile("/normal/path.txt")).toBe(false)
+		expect(pathIncludesDotFile("")).toBe(false)
+	})
+})
+
+describe("Category N — utils default-ignore helpers", () => {
+	it("ignores OS-junk names case-insensitively", () => {
+		expect(isNameIgnoredByDefault(".DS_Store")).toBe(true)
+		expect(isNameIgnoredByDefault(".ds_store")).toBe(true)
+		expect(isNameIgnoredByDefault("thumbs.db")).toBe(true)
+		expect(isNameIgnoredByDefault("desktop.ini")).toBe(true)
+	})
+
+	it("ignores names by lock/owner prefix and ignored extensions", () => {
+		expect(isNameIgnoredByDefault(".~lock.document.odt#")).toBe(true)
+		expect(isNameIgnoredByDefault("~$report.docx")).toBe(true)
+		expect(isNameIgnoredByDefault("scratch.tmp")).toBe(true)
+		// Extension match is case-insensitive.
+		expect(isNameIgnoredByDefault("Scratch.TMP")).toBe(true)
+	})
+
+	it("ignores empty / whitespace-only names", () => {
+		expect(isNameIgnoredByDefault("")).toBe(true)
+		expect(isNameIgnoredByDefault("   ")).toBe(true)
+	})
+
+	it("does NOT ignore an ordinary name", () => {
+		expect(isNameIgnoredByDefault("report.txt")).toBe(false)
+		expect(isNameIgnoredByDefault("photo.jpg")).toBe(false)
+	})
+
+	it("ignores a relative path containing an ignored component or matching a glob", () => {
+		expect(isRelativePathIgnoredByDefault("foo/.DS_Store")).toBe(true)
+		expect(isRelativePathIgnoredByDefault("a/b/thumbs.db")).toBe(true)
+		expect(isRelativePathIgnoredByDefault(".filen.trash.local/sub/file.txt")).toBe(true)
+	})
+
+	it("does NOT ignore an ordinary relative path", () => {
+		expect(isRelativePathIgnoredByDefault("documents/work/report.txt")).toBe(false)
+	})
+
+	it("ignores absolute Windows system paths via globs", () => {
+		expect(isAbsolutePathIgnoredByDefault("C:/Program Files/app/x.dll")).toBe(true)
+		expect(isAbsolutePathIgnoredByDefault("D:/$RECYCLE.BIN/S-1-5/desktop.ini")).toBe(true)
+	})
+
+	it("does NOT ignore an ordinary absolute path", () => {
+		expect(isAbsolutePathIgnoredByDefault("/home/user/documents/file.txt")).toBe(false)
+		expect(isAbsolutePathIgnoredByDefault("C:/Users/me/file.txt")).toBe(false)
+	})
+})
+
+describe("Category N — utils.serializeError / deserializeError", () => {
+	it("captures exactly name, message, stack and stringified", () => {
+		const error = new Error("something failed")
+		const serialized = serializeError(error)
+
+		expect(serialized.name).toBe("Error")
+		expect(serialized.message).toBe("something failed")
+		expect(serialized.stack).toBe(error.stack)
+		expect(serialized.stringified).toBe("Error: something failed")
+		expect(Object.keys(serialized).sort()).toEqual(["message", "name", "stack", "stringified"])
+	})
+
+	it("round-trips name, message and stack through deserializeError", () => {
+		const error = new TypeError("bad type")
+		const restored = deserializeError(serializeError(error))
+
+		expect(restored).toBeInstanceOf(Error)
+		expect(restored.name).toBe("TypeError")
+		expect(restored.message).toBe("bad type")
+		expect(restored.stack).toBe(error.stack)
+	})
+
+	it("does not carry a `code` property across the round-trip (display-oriented contract)", () => {
+		const error = Object.assign(new Error("missing file"), { code: "ENOENT" })
+		const serialized = serializeError(error)
+
+		// `SerializedError` deliberately has no `code` field, so name/message survive but `code` does not.
+		expect(serialized.name).toBe("Error")
+		expect(serialized.message).toBe("missing file")
+		expect("code" in serialized).toBe(false)
+
+		const restored = deserializeError(serialized) as Error & { code?: string }
+
+		expect(restored.message).toBe("missing file")
+		expect(restored.code).toBeUndefined()
+	})
+})
+
+describe("Category N — utils.fastHash", () => {
+	it("is deterministic for identical input", () => {
+		expect(fastHash("the quick brown fox")).toBe(fastHash("the quick brown fox"))
+	})
+
+	it("produces different digests for different input", () => {
+		expect(fastHash("a")).not.toBe(fastHash("b"))
+	})
+
+	it("matches the well-known md5 digests", () => {
+		expect(fastHash("hello")).toBe("5d41402abc4b2a76b9719d911017c592")
+		expect(fastHash("")).toBe("d41d8cd98f00b204e9800998ecf8427e")
+		expect(fastHash("input")).toMatch(/^[0-9a-f]{32}$/)
+	})
+})
+
+describe("Category N — utils.tryingToSyncDesktop", () => {
+	it("matches the user's Desktop path on darwin (case-insensitive, trailing slash tolerant)", () => {
+		withPlatform("darwin", () => {
+			withEnv("USER", "alice", () => {
+				expect(tryingToSyncDesktop("/Users/alice/Desktop")).toBe(true)
+				expect(tryingToSyncDesktop("/Users/alice/Desktop/")).toBe(true)
+				expect(tryingToSyncDesktop("  /users/alice/desktop  ")).toBe(true)
+			})
+		})
+	})
+
+	it("does not match a non-Desktop path on darwin", () => {
+		withPlatform("darwin", () => {
+			withEnv("USER", "alice", () => {
+				expect(tryingToSyncDesktop("/Users/alice/Documents")).toBe(false)
+				expect(tryingToSyncDesktop("/Users/bob/Desktop")).toBe(false)
+			})
+		})
+	})
+
+	it("always returns false on non-darwin platforms", () => {
+		withEnv("USER", "alice", () => {
+			withPlatform("linux", () => {
+				expect(tryingToSyncDesktop("/Users/alice/Desktop")).toBe(false)
+			})
+			withPlatform("win32", () => {
+				expect(tryingToSyncDesktop("/Users/alice/Desktop")).toBe(false)
+			})
+		})
+	})
+})
+
+describe("Category N — utils.replacePathStartWithFromAndTo (edge cases)", () => {
+	it("maps the root onto the new root when from === path", () => {
+		expect(replacePathStartWithFromAndTo("/foo/bar", "/foo/bar", "/baz/qux")).toBe("/baz/qux")
+	})
+
+	it("strips a trailing slash on the path before reparenting", () => {
+		expect(replacePathStartWithFromAndTo("/foo/bar/", "/foo", "/baz")).toBe("/baz/bar")
+	})
+
+	it("strips trailing slashes on from and to", () => {
+		expect(replacePathStartWithFromAndTo("/foo/bar", "/foo/", "/baz/")).toBe("/baz/bar")
+	})
+
+	it("normalizes missing leading slashes on all three inputs", () => {
+		expect(replacePathStartWithFromAndTo("foo/bar", "foo", "baz")).toBe("/baz/bar")
+	})
+
+	it("supports reparenting onto a deeper destination", () => {
+		expect(replacePathStartWithFromAndTo("/a/b/c", "/a", "/x/y/z")).toBe("/x/y/z/b/c")
+	})
+})
+
+describe("Category N — Semaphore", () => {
+	it("starts empty and reports its counter via count()", async () => {
+		const sem = new Semaphore(1)
+
+		expect(sem.count()).toBe(0)
+
+		await sem.acquire()
+
+		expect(sem.count()).toBe(1)
+	})
+
+	it("serializes acquisition with max = 1 until release", async () => {
+		const sem = new Semaphore(1)
+
+		await sem.acquire()
+
+		let secondAcquired = false
+		const second = sem.acquire().then(() => {
+			secondAcquired = true
+		})
+
+		await tick()
+
+		// The second acquire is blocked behind the first holder.
+		expect(secondAcquired).toBe(false)
+		expect(sem.count()).toBe(1)
+
+		sem.release()
+		await second
+
+		expect(secondAcquired).toBe(true)
+		expect(sem.count()).toBe(1)
+
+		sem.release()
+
+		expect(sem.count()).toBe(0)
+	})
+
+	it("ignores release() when nothing is held", () => {
+		const sem = new Semaphore(1)
+
+		expect(() => sem.release()).not.toThrow()
+		expect(sem.count()).toBe(0)
+	})
+
+	it("setMax raises concurrency and unblocks a waiter", async () => {
+		const sem = new Semaphore(1)
+
+		await sem.acquire()
+
+		let secondAcquired = false
+		const second = sem.acquire().then(() => {
+			secondAcquired = true
+		})
+
+		await tick()
+
+		expect(secondAcquired).toBe(false)
+
+		sem.setMax(2)
+		await second
+
+		expect(secondAcquired).toBe(true)
+		expect(sem.count()).toBe(2)
+	})
+
+	it("purge() rejects all waiters, returns their count and resets the counter", async () => {
+		const sem = new Semaphore(1)
+
+		await sem.acquire()
+
+		const first = sem.acquire()
+		const second = sem.acquire()
+		const firstRejection = expect(first).rejects.toBe("Task has been purged")
+		const secondRejection = expect(second).rejects.toBe("Task has been purged")
+
+		const purged = sem.purge()
+
+		expect(purged).toBe(2)
+		expect(sem.count()).toBe(0)
+
+		await firstRejection
+		await secondRejection
+	})
+
+	it("purge() with no waiters returns 0 but still resets the counter", async () => {
+		const sem = new Semaphore(1)
+
+		await sem.acquire()
+
+		expect(sem.count()).toBe(1)
+		expect(sem.purge()).toBe(0)
+		expect(sem.count()).toBe(0)
+	})
+})
+
+describe("Category N — Logger (disabled)", () => {
+	it("constructs and init()s without creating a stream or throwing", async () => {
+		const logger = new Logger(true)
+		const internal = logger as unknown as { logger: unknown; dest: unknown }
+
+		// The disabled branch short-circuits before touching the filesystem.
+		expect(internal.logger).toBeNull()
+		expect(internal.dest).toBeNull()
+
+		await expect(logger.init()).resolves.toBeUndefined()
+
+		expect(internal.logger).toBeNull()
+		expect(internal.dest).toBeNull()
+	})
+
+	it("treats every log() call as a no-op that never throws", () => {
+		const logger = new Logger(true)
+
+		expect(() => {
+			logger.log("info", "a string")
+			logger.log("debug", { nested: { value: 1 } })
+			logger.log("warn", 42, "where")
+			logger.log("error", new Error("ignored"))
+			logger.log("trace")
+			logger.log("fatal", "boom")
+		}).not.toThrow()
+	})
+})