Added additional tests

Author: AndreasArvidsson

src/test/cli.test.ts

@@ -13,7 +13,7 @@ import type {
     Options,
     ParsedArgs,
 } from "../types.js";
-import { EXIT_FAIL, EXIT_OK } from "../util/constants.js";
+import { EXIT_ERROR, EXIT_FAIL, EXIT_OK } from "../util/constants.js";
 import { createLogger, createTestLogger } from "../util/createLogger.js";
 import { getDefaultArguments } from "../util/getDefaultArguments.js";
 import { normalizeToPosix } from "../util/normalizeToPosix.js";
@@ -377,6 +377,41 @@ suite("CLI", () => {
         }
     });
 
+    test("Check mode reports success when all files are unchanged", async () => {
+        const fileName = await createTempFile(
+            "talonfmt-",
+            "example.txt",
+            "content",
+        );
+        const cli = createCLI((text) => text);
+        const originalArgv = process.argv;
+        const originalExitCode = process.exitCode;
+
+        try {
+            process.argv = ["node", "talon-fmt", "--check", fileName];
+
+            const output = await captureStdoutAndStderr(async () => {
+                await main(cli);
+                return process.exitCode;
+            });
+
+            assert.equal(output.result, EXIT_OK);
+            assert.equal(
+                output.stdoutText,
+                [
+                    "Checking formatting...",
+                    "All matched files use correct code style!",
+                    "",
+                ].join("\n"),
+            );
+            assert.equal(output.stderrText, "");
+        } finally {
+            process.argv = originalArgv;
+            process.exitCode = originalExitCode;
+            await cleanupTempFile(fileName);
+        }
+    });
+
     test("Returns success for unchanged stdin in check mode", async () => {
         const cli = createCLI((text) => text);
         const logger = createTestLogger();
@@ -558,6 +593,58 @@ suite("CLI", () => {
         );
     });
 
+    test("Main prints version and exits successfully", async () => {
+        const cli = createCLI((text) => text);
+        const originalArgv = process.argv;
+        const originalExitCode = process.exitCode;
+
+        try {
+            process.argv = ["node", "talon-fmt", "--version"];
+
+            const output = await captureStdoutAndStderr(async () => {
+                await main(cli);
+                return process.exitCode;
+            });
+
+            assert.equal(output.result, EXIT_OK);
+            assert.match(output.stdoutText, /^\d+\.\d+\.\d+\n$/);
+            assert.equal(output.stderrText, "");
+        } finally {
+            process.argv = originalArgv;
+            process.exitCode = originalExitCode;
+        }
+    });
+
+    test("Main reports file pattern errors", async () => {
+        const cli = createCLI((text) => text);
+        const originalArgv = process.argv;
+        const originalExitCode = process.exitCode;
+        const directory = await fs.mkdtemp(path.join(os.tmpdir(), "talonfmt-"));
+        const cwd = process.cwd();
+
+        try {
+            process.chdir(directory);
+            process.argv = ["node", "talon-fmt", "**/*.txt"];
+
+            const output = await captureStdoutAndStderr(async () => {
+                await main(cli);
+                return process.exitCode;
+            });
+
+            assert.equal(output.result, EXIT_ERROR);
+            assert.equal(output.stdoutText, "");
+            assert.equal(
+                output.stderrText,
+                "[error] No files matching the pattern were found: **/*.txt\n",
+            );
+        } finally {
+            process.chdir(cwd);
+            process.argv = originalArgv;
+            process.exitCode = originalExitCode;
+            await fs.rm(directory, { recursive: true, force: true });
+        }
+    });
+
     test("Captures log entries without writing when quiet", async () => {
         const fileName = await createTempFile(
             "talonfmt-",

src/test/getOptionsFromConfig.test.ts

@@ -8,6 +8,24 @@ import type { EditorConfigOptions } from "../types.js";
 import { getOptionsFromConfig } from "../util/getOptionsFromConfig.js";
 
 suite("getOptionsFromConfig", () => {
+    test("indent_style: space sets indentTabs: false", async () => {
+        const fileName = await createTempFile("talonfmt-", "example.talon");
+
+        try {
+            await writeEditorConfig(fileName, {
+                indent_style: "space",
+            });
+
+            const actual = await getOptionsFromConfig(fileName);
+
+            assert.deepEqual(actual, {
+                indentTabs: false,
+            });
+        } finally {
+            await cleanupTempFile(fileName);
+        }
+    });
+
     test("indent_style: tab sets indentTabs: true", async () => {
         const fileName = await createTempFile("talonfmt-", "example.talon");
 
@@ -47,6 +65,24 @@ suite("getOptionsFromConfig", () => {
         }
     });
 
+    test("indent_size: 2 sets indentSize: 2", async () => {
+        const fileName = await createTempFile("talonfmt-", "example.talon");
+
+        try {
+            await writeEditorConfig(fileName, {
+                indent_size: 2,
+            });
+
+            const actual = await getOptionsFromConfig(fileName);
+
+            assert.deepEqual(actual, {
+                indentSize: 2,
+            });
+        } finally {
+            await cleanupTempFile(fileName);
+        }
+    });
+
     test("insert_final_newline: false sets insertFinalNewline: false", async () => {
         const fileName = await createTempFile("talonfmt-", "example.talon");
 
@@ -83,6 +119,42 @@ suite("getOptionsFromConfig", () => {
         }
     });
 
+    test("max_line_length: 80 sets maxLineLength: 80", async () => {
+        const fileName = await createTempFile("talonfmt-", "example.talon");
+
+        try {
+            await writeEditorConfig(fileName, {
+                max_line_length: 80,
+            });
+
+            const actual = await getOptionsFromConfig(fileName);
+
+            assert.deepEqual(actual, {
+                maxLineLength: 80,
+            });
+        } finally {
+            await cleanupTempFile(fileName);
+        }
+    });
+
+    test("column_width: 24 sets columnWidth: 24", async () => {
+        const fileName = await createTempFile("talonfmt-", "example.talon");
+
+        try {
+            await writeEditorConfig(fileName, {
+                column_width: 24,
+            });
+
+            const actual = await getOptionsFromConfig(fileName);
+
+            assert.deepEqual(actual, {
+                columnWidth: 24,
+            });
+        } finally {
+            await cleanupTempFile(fileName);
+        }
+    });
+
     test("end_of_line: crlf sets endOfLine: crlf", async () => {
         const fileName = await createTempFile("talonfmt-", "example.talon");
 

src/test/parseFilePatterns.test.ts

@@ -51,6 +51,34 @@ suite("Parse file patterns", () => {
         }
     });
 
+    test("Expands directories with multiple supported endings", async () => {
+        const directory = await createTempDirectory();
+        const cwd = process.cwd();
+
+        try {
+            await fs.writeFile(path.join(directory, "one.txt"), "one", "utf8");
+            await fs.writeFile(
+                path.join(directory, "two.talon"),
+                "two",
+                "utf8",
+            );
+            await fs.writeFile(path.join(directory, "skip.md"), "skip", "utf8");
+            process.chdir(directory);
+
+            const files = await parseFilePatterns(createCLI(["txt", "talon"]), [
+                ".",
+            ]);
+
+            assert.deepEqual(files, [
+                path.join(directory, "one.txt"),
+                path.join(directory, "two.talon"),
+            ]);
+        } finally {
+            process.chdir(cwd);
+            await cleanupDirectory(directory);
+        }
+    });
+
     test("Ignores hardcoded directories during directory expansion", async () => {
         const directory = await createTempDirectory();
         const cwd = process.cwd();
@@ -105,6 +133,24 @@ suite("Parse file patterns", () => {
         }
     });
 
+    test("Glob patterns filter by supported endings", async () => {
+        const directory = await createTempDirectory();
+        const cwd = process.cwd();
+
+        try {
+            await fs.writeFile(path.join(directory, "one.txt"), "one", "utf8");
+            await fs.writeFile(path.join(directory, "two.md"), "two", "utf8");
+            process.chdir(directory);
+
+            const files = await parseFilePatterns(createCLI(), ["**/*.*"]);
+
+            assert.deepEqual(files, [path.join(directory, "one.txt")]);
+        } finally {
+            process.chdir(cwd);
+            await cleanupDirectory(directory);
+        }
+    });
+
     test("Expands Windows-style glob patterns on Windows", async function () {
         if (path.sep !== "\\") {
             this.skip();
@@ -241,12 +287,35 @@ suite("Parse file patterns", () => {
             await cleanupDirectory(directory);
         }
     });
+
+    test("Aggregates multiple pattern errors", async () => {
+        const directory = await createTempDirectory();
+        const cwd = process.cwd();
+
+        try {
+            process.chdir(directory);
+
+            await assert.rejects(
+                parseFilePatterns(createCLI(), [".", "**/*.txt"]),
+                (error: unknown) =>
+                    error instanceof FilePatternError &&
+                    error.messages.length === 2 &&
+                    error.messages[0] ===
+                        "No matching files were found in the directory: ." &&
+                    error.messages[1] ===
+                        "No files matching the pattern were found: **/*.txt",
+            );
+        } finally {
+            process.chdir(cwd);
+            await cleanupDirectory(directory);
+        }
+    });
 });
 
-function createCLI(): CLI {
+function createCLI(fileEndings: readonly string[] = ["txt"]): CLI {
     return {
         binName: "talon-fmt",
-        fileEndings: ["txt"],
+        fileEndings,
         getStdinFileEnding: () => "txt",
         format: (text) => Promise.resolve(text),
     };

src/test/parseTalonList.test.ts

@@ -0,0 +1,84 @@
+import assert from "node:assert";
+import { parseTalonList, type TalonList } from "../talon/parseTalonList.js";
+
+suite("parseTalonList", () => {
+    test("Parses headers, comments, and items", () => {
+        const fixture = `\
+# header
+list: user.my_list
+tag: user.test
+-
+
+# body
+air: a
+bat
+`;
+
+        const expected: TalonList = {
+            headers: [
+                { type: "comment", text: "# header" },
+                { type: "header", key: "list", value: "user.my_list" },
+                { type: "header", key: "tag", value: "user.test" },
+            ],
+            items: [
+                { type: "comment", text: "# body" },
+                { type: "item", key: "air", value: "a" },
+                { type: "item", key: "bat", value: undefined },
+            ],
+        };
+
+        const actual = parseTalonList(fixture);
+
+        assert.deepEqual(actual, expected);
+    });
+
+    test("trims leading and trailing blank body lines but preserves internal blanks", () => {
+        const fixture = `\
+list : user.my_list
+-
+
+
+air : a
+
+bat: b
+
+
+`;
+
+        const expected: TalonList = {
+            headers: [{ type: "header", key: "list", value: "user.my_list" }],
+            items: [
+                { type: "item", key: "air", value: "a" },
+                { type: "empty" },
+                { type: "item", key: "bat", value: "b" },
+            ],
+        };
+
+        const actual = parseTalonList(fixture);
+
+        assert.deepEqual(actual, expected);
+    });
+
+    test("Supports CRLF input", () => {
+        const actual = parseTalonList("list: user.my_list\r\n-\r\na: b");
+
+        assert.deepEqual(actual, {
+            headers: [{ type: "header", key: "list", value: "user.my_list" }],
+            items: [{ type: "item", key: "a", value: "b" }],
+        });
+    });
+
+    test("Throws when separator is missing", () => {
+        assert.throws(
+            () => parseTalonList("list: user.my_list"),
+            /Separator not found in talon list/,
+        );
+    });
+
+    test("Throws when a header value is missing", () => {
+        assert.throws(
+            () => parseTalonList("list\n-\na: b"),
+            /Header value missing/,
+        );
+    });
+});