From 435f654cbe386af0b03d968558906c585ab17b81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Wed, 23 Jul 2025 21:02:28 +0200
Subject: [PATCH 01/30] test: add unit test for assimp.ts

---
 src/converters/assimp.ts | 10 ++++--
 tests/assimp.test.ts     | 70 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+), 2 deletions(-)
 create mode 100644 tests/assimp.test.ts

diff --git a/src/converters/assimp.ts b/src/converters/assimp.ts
index cac4f9f..9db38ce 100644
--- a/src/converters/assimp.ts
+++ b/src/converters/assimp.ts
@@ -1,4 +1,10 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+
+type ExecFileFn = (
+  cmd: string,
+  args: string[],
+  callback: (err: Error | null, stdout: string, stderr: string) => void,
+) => void;
 
 export const properties = {
   from: {
@@ -116,8 +122,8 @@ export async function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("assimp", ["export", filePath, targetPath], (error, stdout, stderr) => {
diff --git a/tests/assimp.test.ts b/tests/assimp.test.ts
new file mode 100644
index 0000000..062c115
--- /dev/null
+++ b/tests/assimp.test.ts
@@ -0,0 +1,70 @@
+import type { ExecFileException } from "node:child_process";
+import { expect, test } from "bun:test";
+import { convert } from "../src/converters/assimp";
+
+type ExecFileFn = (
+  cmd: string,
+  args: string[],
+  callback: (err: Error | null, stdout: string, stderr: string) => void,
+) => void;
+
+test("convert resolves when execFile succeeds", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert rejects when execFile fails", async () => {
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(new Error("Test error"), "", "");
+  };
+
+  expect(convert("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile)).rejects.toMatch(
+    /error: Error: Test error/,
+  );
+});
+
+test("convert logs stderr when present", async () => {
+  const originalConsoleError = console.error;
+
+  let loggedMessage = "";
+  console.error = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile = (
+    _cmd: string,
+    _args: string[],
+    cb: (err: Error | null, stdout: string, stderr: string) => void,
+  ) => {
+    cb(null, "", "Fake stderr");
+  };
+
+  await convert("file.obj", "obj", "stl", "out.stl", undefined, mockExecFile);
+
+  console.error = originalConsoleError;
+
+  expect(loggedMessage).toBe("stderr: Fake stderr");
+});

From 4fa471263f820a1405820067246d96294a4bc4a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Wed, 23 Jul 2025 21:05:18 +0200
Subject: [PATCH 02/30] test: export type to be usable in test

---
 src/converters/assimp.ts | 2 +-
 tests/assimp.test.ts     | 8 +-------
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/converters/assimp.ts b/src/converters/assimp.ts
index 9db38ce..95aa2b9 100644
--- a/src/converters/assimp.ts
+++ b/src/converters/assimp.ts
@@ -1,6 +1,6 @@
 import { execFile as execFileOriginal } from "node:child_process";
 
-type ExecFileFn = (
+export type ExecFileFn = (
   cmd: string,
   args: string[],
   callback: (err: Error | null, stdout: string, stderr: string) => void,
diff --git a/tests/assimp.test.ts b/tests/assimp.test.ts
index 062c115..fea0e9f 100644
--- a/tests/assimp.test.ts
+++ b/tests/assimp.test.ts
@@ -1,12 +1,6 @@
 import type { ExecFileException } from "node:child_process";
 import { expect, test } from "bun:test";
-import { convert } from "../src/converters/assimp";
-
-type ExecFileFn = (
-  cmd: string,
-  args: string[],
-  callback: (err: Error | null, stdout: string, stderr: string) => void,
-) => void;
+import { convert, ExecFileFn } from "../src/converters/assimp";
 
 test("convert resolves when execFile succeeds", async () => {
   const originalConsoleLog = console.log;

From 2db99edeaf9b8f15b85cd8b1e52c37359171496e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Wed, 23 Jul 2025 21:11:12 +0200
Subject: [PATCH 03/30] test: move test file into separate subfolder

---
 tests/{ => converters}/assimp.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename tests/{ => converters}/assimp.test.ts (96%)

diff --git a/tests/assimp.test.ts b/tests/converters/assimp.test.ts
similarity index 96%
rename from tests/assimp.test.ts
rename to tests/converters/assimp.test.ts
index fea0e9f..d1b28a8 100644
--- a/tests/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -1,6 +1,6 @@
 import type { ExecFileException } from "node:child_process";
 import { expect, test } from "bun:test";
-import { convert, ExecFileFn } from "../src/converters/assimp";
+import { convert, ExecFileFn } from "../../src/converters/assimp.ts";
 
 test("convert resolves when execFile succeeds", async () => {
   const originalConsoleLog = console.log;

From 2c904542440eb0898801ff8944ecd8ce24b36bd6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 10:42:36 +0200
Subject: [PATCH 04/30] test: extract ExecFileFn type to separate file to make
 it reusable

---
 src/converters/assimp.ts | 9 ++-------
 src/converters/types.ts  | 5 +++++
 2 files changed, 7 insertions(+), 7 deletions(-)
 create mode 100644 src/converters/types.ts

diff --git a/src/converters/assimp.ts b/src/converters/assimp.ts
index 95aa2b9..869f28e 100644
--- a/src/converters/assimp.ts
+++ b/src/converters/assimp.ts
@@ -1,10 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-
-export type ExecFileFn = (
-  cmd: string,
-  args: string[],
-  callback: (err: Error | null, stdout: string, stderr: string) => void,
-) => void;
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -123,7 +118,7 @@ export async function convert(
   convertTo: string,
   targetPath: string,
   options?: unknown,
-  execFile: ExecFileFn = execFileOriginal,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("assimp", ["export", filePath, targetPath], (error, stdout, stderr) => {
diff --git a/src/converters/types.ts b/src/converters/types.ts
new file mode 100644
index 0000000..a80a873
--- /dev/null
+++ b/src/converters/types.ts
@@ -0,0 +1,5 @@
+export type ExecFileFn = (
+  cmd: string,
+  args: string[],
+  callback: (err: Error | null, stdout: string, stderr: string) => void,
+) => void;

From 301fab5c1741be02c62124e91f9ac1c4670ef6e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 10:43:28 +0200
Subject: [PATCH 05/30] test: fix import in test

---
 tests/converters/assimp.test.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/converters/assimp.test.ts b/tests/converters/assimp.test.ts
index d1b28a8..98024a0 100644
--- a/tests/converters/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -1,6 +1,7 @@
 import type { ExecFileException } from "node:child_process";
 import { expect, test } from "bun:test";
-import { convert, ExecFileFn } from "../../src/converters/assimp.ts";
+import { convert } from "../../src/converters/assimp.ts";
+import { ExecFileFn } from "../../src/converters/types.ts";
 
 test("convert resolves when execFile succeeds", async () => {
   const originalConsoleLog = console.log;

From fd4e73e76c9c238619b824db32ea6b205c7949ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 11:24:12 +0200
Subject: [PATCH 06/30] test: add unit test for calibre.ts

---
 src/converters/calibre.ts        | 33 ++++++++--------
 src/converters/types.ts          |  9 +++++
 tests/converters/assimp.test.ts  | 64 +++++---------------------------
 tests/converters/calibre.test.ts | 19 ++++++++++
 tests/helpers/converters.test.ts | 64 ++++++++++++++++++++++++++++++++
 5 files changed, 116 insertions(+), 73 deletions(-)
 create mode 100644 tests/converters/calibre.test.ts
 create mode 100644 tests/helpers/converters.test.ts

diff --git a/src/converters/calibre.ts b/src/converters/calibre.ts
index 8ebdbd1..153de16 100644
--- a/src/converters/calibre.ts
+++ b/src/converters/calibre.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -62,28 +63,24 @@ export async function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile(
-      "ebook-convert",
-      [filePath, targetPath],
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(`error: ${error}`);
-        }
+    execFile("ebook-convert", [filePath, targetPath], (error, stdout, stderr) => {
+      if (error) {
+        reject(`error: ${error}`);
+      }
 
-        if (stdout) {
-          console.log(`stdout: ${stdout}`);
-        }
+      if (stdout) {
+        console.log(`stdout: ${stdout}`);
+      }
 
-        if (stderr) {
-          console.error(`stderr: ${stderr}`);
-        }
+      if (stderr) {
+        console.error(`stderr: ${stderr}`);
+      }
 
-        resolve("Done");
-      },
-    );
+      resolve("Done");
+    });
   });
 }
diff --git a/src/converters/types.ts b/src/converters/types.ts
index a80a873..5d7dc9f 100644
--- a/src/converters/types.ts
+++ b/src/converters/types.ts
@@ -3,3 +3,12 @@ export type ExecFileFn = (
   args: string[],
   callback: (err: Error | null, stdout: string, stderr: string) => void,
 ) => void;
+
+export type ConvertFnWithExecFile = (
+  filePath: string,
+  fileType: string,
+  convertTo: string,
+  targetPath: string,
+  options: unknown,
+  execFileOverride?: ExecFileFn,
+) => Promise<string>;
diff --git a/tests/converters/assimp.test.ts b/tests/converters/assimp.test.ts
index 98024a0..5b9f82d 100644
--- a/tests/converters/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -1,65 +1,19 @@
-import type { ExecFileException } from "node:child_process";
-import { expect, test } from "bun:test";
+import { test } from "bun:test";
 import { convert } from "../../src/converters/assimp.ts";
-import { ExecFileFn } from "../../src/converters/types.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "../helpers/converters.test.ts";
 
 test("convert resolves when execFile succeeds", async () => {
-  const originalConsoleLog = console.log;
-
-  let loggedMessage = "";
-  console.log = (msg) => {
-    loggedMessage = msg;
-  };
-
-  const mockExecFile: ExecFileFn = (
-    _cmd: string,
-    _args: string[],
-    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
-  ) => {
-    callback(null, "Fake stdout", "");
-  };
-
-  const result = await convert("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile);
-
-  console.log = originalConsoleLog;
-
-  expect(result).toBe("Done");
-  expect(loggedMessage).toBe("stdout: Fake stdout");
+  await runConvertSuccessTest(convert);
 });
 
 test("convert rejects when execFile fails", async () => {
-  const mockExecFile: ExecFileFn = (
-    _cmd: string,
-    _args: string[],
-    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
-  ) => {
-    callback(new Error("Test error"), "", "");
-  };
-
-  expect(convert("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile)).rejects.toMatch(
-    /error: Error: Test error/,
-  );
+  await runConvertFailTest(convert);
 });
 
 test("convert logs stderr when present", async () => {
-  const originalConsoleError = console.error;
-
-  let loggedMessage = "";
-  console.error = (msg) => {
-    loggedMessage = msg;
-  };
-
-  const mockExecFile = (
-    _cmd: string,
-    _args: string[],
-    cb: (err: Error | null, stdout: string, stderr: string) => void,
-  ) => {
-    cb(null, "", "Fake stderr");
-  };
-
-  await convert("file.obj", "obj", "stl", "out.stl", undefined, mockExecFile);
-
-  console.error = originalConsoleError;
-
-  expect(loggedMessage).toBe("stderr: Fake stderr");
+  await runConvertLogsStderror(convert);
 });
diff --git a/tests/converters/calibre.test.ts b/tests/converters/calibre.test.ts
new file mode 100644
index 0000000..b927bfe
--- /dev/null
+++ b/tests/converters/calibre.test.ts
@@ -0,0 +1,19 @@
+import { test } from "bun:test";
+import { convert } from "../../src/converters/calibre.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "../helpers/converters.test.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});
diff --git a/tests/helpers/converters.test.ts b/tests/helpers/converters.test.ts
new file mode 100644
index 0000000..f533d8a
--- /dev/null
+++ b/tests/helpers/converters.test.ts
@@ -0,0 +1,64 @@
+import type { ExecFileException } from "node:child_process";
+import { expect } from "bun:test";
+import { ConvertFnWithExecFile, ExecFileFn } from "../../src/converters/types.ts";
+
+export async function runConvertSuccessTest(convertFn: ConvertFnWithExecFile) {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convertFn("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+}
+
+export async function runConvertFailTest(convertFn: ConvertFnWithExecFile) {
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(new Error("Test error"), "", "");
+  };
+
+  expect(
+    convertFn("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile),
+  ).rejects.toMatch(/error: Error: Test error/);
+}
+
+export async function runConvertLogsStderror(convertFn: ConvertFnWithExecFile) {
+  const originalConsoleError = console.error;
+
+  let loggedMessage = "";
+  console.error = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile = (
+    _cmd: string,
+    _args: string[],
+    cb: (err: Error | null, stdout: string, stderr: string) => void,
+  ) => {
+    cb(null, "", "Fake stderr");
+  };
+
+  await convertFn("file.obj", "obj", "stl", "out.stl", undefined, mockExecFile);
+
+  console.error = originalConsoleError;
+
+  expect(loggedMessage).toBe("stderr: Fake stderr");
+}

From 3975c70de7d92a2fc7e7af940d20dcd2247522c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 11:27:23 +0200
Subject: [PATCH 07/30] test: move converters test helper to avoid confusion

---
 tests/converters/assimp.test.ts                                 | 2 +-
 tests/converters/calibre.test.ts                                | 2 +-
 .../converters.test.ts => converters/convertersHelper.test.ts}  | 0
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename tests/{helpers/converters.test.ts => converters/convertersHelper.test.ts} (100%)

diff --git a/tests/converters/assimp.test.ts b/tests/converters/assimp.test.ts
index 5b9f82d..afbdc97 100644
--- a/tests/converters/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -4,7 +4,7 @@ import {
   runConvertFailTest,
   runConvertLogsStderror,
   runConvertSuccessTest,
-} from "../helpers/converters.test.ts";
+} from "./convertersHelper.test.ts";
 
 test("convert resolves when execFile succeeds", async () => {
   await runConvertSuccessTest(convert);
diff --git a/tests/converters/calibre.test.ts b/tests/converters/calibre.test.ts
index b927bfe..c8dbf00 100644
--- a/tests/converters/calibre.test.ts
+++ b/tests/converters/calibre.test.ts
@@ -4,7 +4,7 @@ import {
   runConvertFailTest,
   runConvertLogsStderror,
   runConvertSuccessTest,
-} from "../helpers/converters.test.ts";
+} from "./convertersHelper.test.ts";
 
 test("convert resolves when execFile succeeds", async () => {
   await runConvertSuccessTest(convert);
diff --git a/tests/helpers/converters.test.ts b/tests/converters/convertersHelper.test.ts
similarity index 100%
rename from tests/helpers/converters.test.ts
rename to tests/converters/convertersHelper.test.ts

From c47c1dd4f462a6cdaebf28a024caaf5a54b2db9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 11:40:11 +0200
Subject: [PATCH 08/30] test: add unit test for dvisvgm.ts

---
 src/converters/dvisvgm.ts                     |  5 +-
 tests/converters/assimp.test.ts               |  2 +-
 tests/converters/calibre.test.ts              |  2 +-
 tests/converters/dvisvgm.test.ts              | 93 +++++++++++++++++++
 .../converters.ts}                            |  2 +-
 5 files changed, 99 insertions(+), 5 deletions(-)
 create mode 100644 tests/converters/dvisvgm.test.ts
 rename tests/converters/{convertersHelper.test.ts => helpers/converters.ts} (95%)

diff --git a/src/converters/dvisvgm.ts b/src/converters/dvisvgm.ts
index a9ce593..76ef5c1 100644
--- a/src/converters/dvisvgm.ts
+++ b/src/converters/dvisvgm.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -14,8 +15,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   const inputArgs: string[] = [];
   if (fileType === "eps") {
diff --git a/tests/converters/assimp.test.ts b/tests/converters/assimp.test.ts
index afbdc97..01ba0ad 100644
--- a/tests/converters/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -4,7 +4,7 @@ import {
   runConvertFailTest,
   runConvertLogsStderror,
   runConvertSuccessTest,
-} from "./convertersHelper.test.ts";
+} from "./helpers/converters.ts";
 
 test("convert resolves when execFile succeeds", async () => {
   await runConvertSuccessTest(convert);
diff --git a/tests/converters/calibre.test.ts b/tests/converters/calibre.test.ts
index c8dbf00..d060097 100644
--- a/tests/converters/calibre.test.ts
+++ b/tests/converters/calibre.test.ts
@@ -4,7 +4,7 @@ import {
   runConvertFailTest,
   runConvertLogsStderror,
   runConvertSuccessTest,
-} from "./convertersHelper.test.ts";
+} from "./helpers/converters.ts";
 
 test("convert resolves when execFile succeeds", async () => {
   await runConvertSuccessTest(convert);
diff --git a/tests/converters/dvisvgm.test.ts b/tests/converters/dvisvgm.test.ts
new file mode 100644
index 0000000..977f065
--- /dev/null
+++ b/tests/converters/dvisvgm.test.ts
@@ -0,0 +1,93 @@
+import type { ExecFileException } from "node:child_process";
+import { expect, test } from "bun:test";
+import { convert } from "../../src/converters/dvisvgm.ts";
+import { ExecFileFn } from "../../src/converters/types.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});
+
+test("convert respects eps filetype", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.obj", "eps", "stl", "output.stl", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert respects pdf filetype", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.obj", "pdf", "stl", "output.stl", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert respects svgz conversion target type", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.obj", "eps", "svgz", "output.stl", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
diff --git a/tests/converters/convertersHelper.test.ts b/tests/converters/helpers/converters.ts
similarity index 95%
rename from tests/converters/convertersHelper.test.ts
rename to tests/converters/helpers/converters.ts
index f533d8a..fe04d7e 100644
--- a/tests/converters/convertersHelper.test.ts
+++ b/tests/converters/helpers/converters.ts
@@ -1,6 +1,6 @@
 import type { ExecFileException } from "node:child_process";
 import { expect } from "bun:test";
-import { ConvertFnWithExecFile, ExecFileFn } from "../../src/converters/types.ts";
+import { ConvertFnWithExecFile, ExecFileFn } from "../../../src/converters/types.ts";
 
 export async function runConvertSuccessTest(convertFn: ConvertFnWithExecFile) {
   const originalConsoleLog = console.log;

From 72b484a480be6c19c7046e8fb6be9b0a5cc05632 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 12:29:11 +0200
Subject: [PATCH 09/30] test: add unit test for ffmpeg.ts

---
 src/converters/ffmpeg.ts        |   5 +-
 tests/converters/ffmpeg.test.ts | 157 ++++++++++++++++++++++++++++++++
 2 files changed, 160 insertions(+), 2 deletions(-)
 create mode 100644 tests/converters/ffmpeg.test.ts

diff --git a/src/converters/ffmpeg.ts b/src/converters/ffmpeg.ts
index b8bc796..8207c61 100644
--- a/src/converters/ffmpeg.ts
+++ b/src/converters/ffmpeg.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 // This could be done dynamically by running `ffmpeg -formats` and parsing the output
 export const properties = {
@@ -691,8 +692,8 @@ export async function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   let extraArgs: string[] = [];
   let message = "Done";
diff --git a/tests/converters/ffmpeg.test.ts b/tests/converters/ffmpeg.test.ts
new file mode 100644
index 0000000..2bb375a
--- /dev/null
+++ b/tests/converters/ffmpeg.test.ts
@@ -0,0 +1,157 @@
+import { beforeEach, expect, test } from "bun:test";
+import { convert } from "../../src/converters/ffmpeg.ts";
+
+let calls: string[][] = [];
+
+function mockExecFile(
+  _cmd: string,
+  args: string[],
+  callback: (err: Error | null, stdout: string, stderr: string) => void,
+) {
+  calls.push(args);
+  if (args.includes("fail.mov")) {
+    callback(new Error("mock failure"), "", "Fake stderr: fail");
+  } else {
+    callback(null, "Fake stdout", "");
+  }
+}
+
+beforeEach(() => {
+  calls = [];
+  delete process.env.FFMPEG_ARGS;
+});
+
+test("converts a normal file", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const result = await convert("in.mp4", "mp4", "avi", "out.avi", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(calls[0]).toEqual(expect.arrayContaining(["-i", "in.mp4", "out.avi"]));
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("adds resize for ico output", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const result = await convert("in.png", "png", "ico", "out.ico", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done: resized to 256x256");
+  expect(calls[0]).toEqual(
+    expect.arrayContaining(["-filter:v", expect.stringContaining("scale=")]),
+  );
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("uses libaom-av1 for av1.mp4", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  await convert("in.mkv", "mkv", "av1.mp4", "out.mp4", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(calls[0]).toEqual(expect.arrayContaining(["-c:v", "libaom-av1"]));
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("uses libx264 for h264.mp4", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  await convert("in.mkv", "mkv", "h264.mp4", "out.mp4", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(calls[0]).toEqual(expect.arrayContaining(["-c:v", "libx264"]));
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("uses libx265 for h265.mp4", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  await convert("in.mkv", "mkv", "h265.mp4", "out.mp4", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(calls[0]).toEqual(expect.arrayContaining(["-c:v", "libx265"]));
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("uses libx266 for h266.mp4", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  await convert("in.mkv", "mkv", "h266.mp4", "out.mp4", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(calls[0]).toEqual(expect.arrayContaining(["-c:v", "libx266"]));
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("respects FFMPEG_ARGS", async () => {
+  process.env.FFMPEG_ARGS = "-hide_banner -y";
+
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  await convert("input.mov", "mov", "mp4", "output.mp4", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(calls[0]?.slice(0, 2)).toEqual(["-hide_banner", "-y"]);
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("fails on exec error", async () => {
+  const originalConsoleError = console.error;
+
+  let loggedMessage = "";
+  console.error = (msg) => {
+    loggedMessage = msg;
+  };
+
+  expect(convert("fail.mov", "mov", "mp4", "output.mp4", undefined, mockExecFile)).rejects.toThrow(
+    "mock failure",
+  );
+
+  console.error = originalConsoleError;
+
+  expect(loggedMessage).toBe("stderr: Fake stderr: fail");
+});

From 7f9c8868fd3690d8c1e96dabcd938c56e3580b41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 13:18:16 +0200
Subject: [PATCH 10/30] test: add unit test for graphicsmagick.ts

---
 src/converters/graphicsmagick.ts        |  5 +++--
 tests/converters/graphicsmagick.test.ts | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 tests/converters/graphicsmagick.test.ts

diff --git a/src/converters/graphicsmagick.ts b/src/converters/graphicsmagick.ts
index dbd8996..6a52ea8 100644
--- a/src/converters/graphicsmagick.ts
+++ b/src/converters/graphicsmagick.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -313,8 +314,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("gm", ["convert", filePath, targetPath], (error, stdout, stderr) => {
diff --git a/tests/converters/graphicsmagick.test.ts b/tests/converters/graphicsmagick.test.ts
new file mode 100644
index 0000000..df9bda8
--- /dev/null
+++ b/tests/converters/graphicsmagick.test.ts
@@ -0,0 +1,19 @@
+import { test } from "bun:test";
+import { convert } from "../../src/converters/graphicsmagick.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});

From f1730ede974d12c580381ac544f2e86e8e0964c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 13:50:29 +0200
Subject: [PATCH 11/30] test: add unit test for imagemagick.ts

---
 src/converters/imagemagick.ts        |   5 +-
 tests/converters/dvisvgm.test.ts     |  20 ++-
 tests/converters/imagemagick.test.ts | 179 +++++++++++++++++++++++++++
 3 files changed, 198 insertions(+), 6 deletions(-)
 create mode 100644 tests/converters/imagemagick.test.ts

diff --git a/src/converters/imagemagick.ts b/src/converters/imagemagick.ts
index 919308b..9f4ff94 100644
--- a/src/converters/imagemagick.ts
+++ b/src/converters/imagemagick.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 // declare possible conversions
 export const properties = {
@@ -445,8 +446,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   let outputArgs: string[] = [];
   let inputArgs: string[] = [];
diff --git a/tests/converters/dvisvgm.test.ts b/tests/converters/dvisvgm.test.ts
index 977f065..873b4db 100644
--- a/tests/converters/dvisvgm.test.ts
+++ b/tests/converters/dvisvgm.test.ts
@@ -1,5 +1,5 @@
 import type { ExecFileException } from "node:child_process";
-import { expect, test } from "bun:test";
+import { beforeEach, expect, test } from "bun:test";
 import { convert } from "../../src/converters/dvisvgm.ts";
 import { ExecFileFn } from "../../src/converters/types.ts";
 import {
@@ -8,6 +8,12 @@ import {
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
+let calls: string[][] = [];
+
+beforeEach(() => {
+  calls = [];
+});
+
 test("convert resolves when execFile succeeds", async () => {
   await runConvertSuccessTest(convert);
 });
@@ -33,14 +39,16 @@ test("convert respects eps filetype", async () => {
     _args: string[],
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
+    calls.push(_args);
     callback(null, "Fake stdout", "");
   };
 
-  const result = await convert("input.obj", "eps", "stl", "output.stl", undefined, mockExecFile);
+  const result = await convert("input.eps", "eps", "stl", "output.stl", undefined, mockExecFile);
 
   console.log = originalConsoleLog;
 
   expect(result).toBe("Done");
+  expect(calls[0]).toEqual(expect.arrayContaining(["--eps", "input.eps", "output.stl"]));
   expect(loggedMessage).toBe("stdout: Fake stdout");
 });
 
@@ -57,14 +65,16 @@ test("convert respects pdf filetype", async () => {
     _args: string[],
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
+    calls.push(_args);
     callback(null, "Fake stdout", "");
   };
 
-  const result = await convert("input.obj", "pdf", "stl", "output.stl", undefined, mockExecFile);
+  const result = await convert("input.pdf", "pdf", "stl", "output.stl", undefined, mockExecFile);
 
   console.log = originalConsoleLog;
 
   expect(result).toBe("Done");
+  expect(calls[0]).toEqual(expect.arrayContaining(["--pdf", "input.pdf", "output.stl"]));
   expect(loggedMessage).toBe("stdout: Fake stdout");
 });
 
@@ -81,13 +91,15 @@ test("convert respects svgz conversion target type", async () => {
     _args: string[],
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
+    calls.push(_args);
     callback(null, "Fake stdout", "");
   };
 
-  const result = await convert("input.obj", "eps", "svgz", "output.stl", undefined, mockExecFile);
+  const result = await convert("input.obj", "eps", "svgz", "output.svgz", undefined, mockExecFile);
 
   console.log = originalConsoleLog;
 
   expect(result).toBe("Done");
+  expect(calls[0]).toEqual(expect.arrayContaining(["-z", "input.obj", "output.svgz"]));
   expect(loggedMessage).toBe("stdout: Fake stdout");
 });
diff --git a/tests/converters/imagemagick.test.ts b/tests/converters/imagemagick.test.ts
new file mode 100644
index 0000000..26ec4a9
--- /dev/null
+++ b/tests/converters/imagemagick.test.ts
@@ -0,0 +1,179 @@
+import type { ExecFileException } from "node:child_process";
+import { beforeEach, expect, test } from "bun:test";
+import { convert } from "../../src/converters/imagemagick.ts";
+import { ExecFileFn } from "../../src/converters/types.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+let calls: string[][] = [];
+
+beforeEach(() => {
+  calls = [];
+});
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});
+
+test("convert respects ico conversion target type", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    calls.push(_args);
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.obj", "eps", "ico", "output.ico", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(calls[0]).toEqual(
+    expect.arrayContaining([
+      "-define",
+      "icon:auto-resize=256,128,64,48,32,16",
+      "-background",
+      "none",
+      "input.obj",
+      "output.ico",
+    ]),
+  );
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert respects ico conversion target type with svg as input filetype", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    calls.push(_args);
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.svg", "svg", "ico", "output.ico", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(calls[0]).toEqual(
+    expect.arrayContaining([
+      "-define",
+      "icon:auto-resize=256,128,64,48,32,16",
+      "-background",
+      "none",
+      "-density",
+      "512",
+      "input.svg",
+      "output.ico",
+    ]),
+  );
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert respects ico conversion target type with emf as input filetype", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    calls.push(_args);
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.emf", "emf", "ico", "output.ico", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(calls[0]).toEqual(
+    expect.arrayContaining([
+      "-define",
+      "icon:auto-resize=256,128,64,48,32,16",
+      "-background",
+      "none",
+      "emf:delegate=false",
+      "-density",
+      "300",
+      "white",
+      "-alpha",
+      "remove",
+      "input.emf",
+      "output.ico",
+    ]),
+  );
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert respects emf as input filetype", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    calls.push(_args);
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.emf", "emf", "obj", "output.obj", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(calls[0]).toEqual(
+    expect.arrayContaining([
+      "-define",
+      "emf:delegate=false",
+      "-density",
+      "300",
+      "-background",
+      "white",
+      "-alpha",
+      "remove",
+      "input.emf",
+      "output.obj",
+    ]),
+  );
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});

From 7524f304fe2402fdb0f038a47f0d3689c7e929ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 13:53:41 +0200
Subject: [PATCH 12/30] test: add unit test for inkscape.ts

---
 src/converters/graphicsmagick.ts  |  2 +-
 src/converters/imagemagick.ts     |  2 +-
 src/converters/inkscape.ts        |  5 +++--
 tests/converters/inkscape.test.ts | 19 +++++++++++++++++++
 4 files changed, 24 insertions(+), 4 deletions(-)
 create mode 100644 tests/converters/inkscape.test.ts

diff --git a/src/converters/graphicsmagick.ts b/src/converters/graphicsmagick.ts
index 6a52ea8..5551341 100644
--- a/src/converters/graphicsmagick.ts
+++ b/src/converters/graphicsmagick.ts
@@ -315,7 +315,7 @@ export function convert(
   convertTo: string,
   targetPath: string,
   options?: unknown,
-  execFile: ExecFileFn = execFileOriginal,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("gm", ["convert", filePath, targetPath], (error, stdout, stderr) => {
diff --git a/src/converters/imagemagick.ts b/src/converters/imagemagick.ts
index 9f4ff94..eb2eaa7 100644
--- a/src/converters/imagemagick.ts
+++ b/src/converters/imagemagick.ts
@@ -447,7 +447,7 @@ export function convert(
   convertTo: string,
   targetPath: string,
   options?: unknown,
-  execFile: ExecFileFn = execFileOriginal,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   let outputArgs: string[] = [];
   let inputArgs: string[] = [];
diff --git a/src/converters/inkscape.ts b/src/converters/inkscape.ts
index 9e13fb0..4497e2f 100644
--- a/src/converters/inkscape.ts
+++ b/src/converters/inkscape.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -32,8 +33,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("inkscape", [filePath, "-o", targetPath], (error, stdout, stderr) => {
diff --git a/tests/converters/inkscape.test.ts b/tests/converters/inkscape.test.ts
new file mode 100644
index 0000000..39d21c3
--- /dev/null
+++ b/tests/converters/inkscape.test.ts
@@ -0,0 +1,19 @@
+import { test } from "bun:test";
+import { convert } from "../../src/converters/inkscape.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});

From 5957873534c823db82966a8309607da10ecedc84 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 14:35:42 +0200
Subject: [PATCH 13/30] test: add unit test for libheif.ts

---
 src/converters/libheif.ts        |  5 +++--
 tests/converters/libheif.test.ts | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 tests/converters/libheif.test.ts

diff --git a/src/converters/libheif.ts b/src/converters/libheif.ts
index 38ac949..b88e177 100644
--- a/src/converters/libheif.ts
+++ b/src/converters/libheif.ts
@@ -1,4 +1,5 @@
-import { execFile } from "child_process";
+import { execFile as execFileOriginal } from "child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -14,8 +15,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("heif-convert", [filePath, targetPath], (error, stdout, stderr) => {
diff --git a/tests/converters/libheif.test.ts b/tests/converters/libheif.test.ts
new file mode 100644
index 0000000..33625c5
--- /dev/null
+++ b/tests/converters/libheif.test.ts
@@ -0,0 +1,19 @@
+import { test } from "bun:test";
+import { convert } from "../../src/converters/libheif.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});

From 311d2516ce94a751817e00e5b0d0011536e87598 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 17:56:19 +0200
Subject: [PATCH 14/30] test: add unit test for libjxl.ts

---
 src/converters/libjxl.ts        |  5 ++-
 tests/converters/libjxl.test.ts | 79 +++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+), 2 deletions(-)
 create mode 100644 tests/converters/libjxl.test.ts

diff --git a/src/converters/libjxl.ts b/src/converters/libjxl.ts
index 0ef11a8..6ff825f 100644
--- a/src/converters/libjxl.ts
+++ b/src/converters/libjxl.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 // declare possible conversions
 export const properties = {
@@ -17,8 +18,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   let tool = "";
   if (fileType === "jxl") {
diff --git a/tests/converters/libjxl.test.ts b/tests/converters/libjxl.test.ts
new file mode 100644
index 0000000..cea851b
--- /dev/null
+++ b/tests/converters/libjxl.test.ts
@@ -0,0 +1,79 @@
+import type { ExecFileException } from "node:child_process";
+import { beforeEach, expect, test } from "bun:test";
+import { convert } from "../../src/converters/libjxl.ts";
+import { ExecFileFn } from "../../src/converters/types.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+let command: string = "";
+
+beforeEach(() => {
+  command = "";
+});
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});
+
+test("convert uses djxl with input filetype being jxl", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    command = _cmd;
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.jxl", "jxl", "png", "output.png", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(command).toEqual("djxl");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert uses cjxl with output filetype being jxl", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    command = _cmd;
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.png", "png", "jxl", "output.jxl", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(command).toEqual("cjxl");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});

From b1f70ec36cafadff11a201f2ebe3ac1aaa32ae6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 18:00:15 +0200
Subject: [PATCH 15/30] test: add unit test for potrace.ts

---
 src/converters/potrace.ts        |  5 +++--
 tests/converters/potrace.test.ts | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 tests/converters/potrace.test.ts

diff --git a/src/converters/potrace.ts b/src/converters/potrace.ts
index cdf09cc..bc90503 100644
--- a/src/converters/potrace.ts
+++ b/src/converters/potrace.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -26,8 +27,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("potrace", [filePath, "-o", targetPath, "-b", convertTo], (error, stdout, stderr) => {
diff --git a/tests/converters/potrace.test.ts b/tests/converters/potrace.test.ts
new file mode 100644
index 0000000..5f37450
--- /dev/null
+++ b/tests/converters/potrace.test.ts
@@ -0,0 +1,19 @@
+import { test } from "bun:test";
+import { convert } from "../../src/converters/potrace.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});

From d8cbc0aaeef6eb739b3779caf7770250fbd46afc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 18:02:13 +0200
Subject: [PATCH 16/30] test: add unit test for resvg.ts

---
 src/converters/potrace.ts      |  2 +-
 src/converters/resvg.ts        |  5 +++--
 tests/converters/resvg.test.ts | 19 +++++++++++++++++++
 3 files changed, 23 insertions(+), 3 deletions(-)
 create mode 100644 tests/converters/resvg.test.ts

diff --git a/src/converters/potrace.ts b/src/converters/potrace.ts
index bc90503..6027491 100644
--- a/src/converters/potrace.ts
+++ b/src/converters/potrace.ts
@@ -28,7 +28,7 @@ export function convert(
   convertTo: string,
   targetPath: string,
   options?: unknown,
-  execFile: ExecFileFn = execFileOriginal,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("potrace", [filePath, "-o", targetPath, "-b", convertTo], (error, stdout, stderr) => {
diff --git a/src/converters/resvg.ts b/src/converters/resvg.ts
index 1e409cb..3155483 100644
--- a/src/converters/resvg.ts
+++ b/src/converters/resvg.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -14,8 +15,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     execFile("resvg", [filePath, targetPath], (error, stdout, stderr) => {
diff --git a/tests/converters/resvg.test.ts b/tests/converters/resvg.test.ts
new file mode 100644
index 0000000..d2eae2f
--- /dev/null
+++ b/tests/converters/resvg.test.ts
@@ -0,0 +1,19 @@
+import { test } from "bun:test";
+import { convert } from "../../src/converters/resvg.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});

From 9f6b815197d70640916359cf1ae73da84330a3a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 18:08:31 +0200
Subject: [PATCH 17/30] test: add unit test for vips.ts

---
 src/converters/vips.ts        |  5 ++-
 tests/converters/vips.test.ts | 79 +++++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+), 2 deletions(-)
 create mode 100644 tests/converters/vips.test.ts

diff --git a/src/converters/vips.ts b/src/converters/vips.ts
index 6451cda..b89db12 100644
--- a/src/converters/vips.ts
+++ b/src/converters/vips.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 // declare possible conversions
 export const properties = {
@@ -94,8 +95,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   // if (fileType === "svg") {
   //   const scale = options.scale || 1;
diff --git a/tests/converters/vips.test.ts b/tests/converters/vips.test.ts
new file mode 100644
index 0000000..dec12dd
--- /dev/null
+++ b/tests/converters/vips.test.ts
@@ -0,0 +1,79 @@
+import type { ExecFileException } from "node:child_process";
+import { beforeEach, expect, test } from "bun:test";
+import { ExecFileFn } from "../../src/converters/types.ts";
+import { convert } from "../../src/converters/vips.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+let calls: string[][] = [];
+
+beforeEach(() => {
+  calls = [];
+});
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});
+
+test("convert uses action pdfload with filetype being pdf", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    calls.push(_args);
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.pdf", "pdf", "obj", "output.obj", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(calls[0]).toEqual(expect.arrayContaining(["pdfload"]));
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});
+
+test("convert uses action copy with filetype being anything but pdf", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    calls.push(_args);
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.jpg", "jpg", "obj", "output.obj", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(calls[0]).toEqual(expect.arrayContaining(["copy"]));
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});

From 6452d0b357cbf07a9c82f9eaa572463ce1a145d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 18:10:55 +0200
Subject: [PATCH 18/30] test: add unit test for xelatex.ts

---
 src/converters/xelatex.ts        |  5 +++--
 tests/converters/xelatex.test.ts | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 tests/converters/xelatex.test.ts

diff --git a/src/converters/xelatex.ts b/src/converters/xelatex.ts
index 5b29356..784acdc 100644
--- a/src/converters/xelatex.ts
+++ b/src/converters/xelatex.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -14,8 +15,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     // const fileName: string = (targetPath.split("/").pop() as string).replace(".pdf", "")
diff --git a/tests/converters/xelatex.test.ts b/tests/converters/xelatex.test.ts
new file mode 100644
index 0000000..5d81d09
--- /dev/null
+++ b/tests/converters/xelatex.test.ts
@@ -0,0 +1,19 @@
+import { test } from "bun:test";
+import { convert } from "../../src/converters/xelatex.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertSuccessTest,
+} from "./helpers/converters.ts";
+
+test("convert resolves when execFile succeeds", async () => {
+  await runConvertSuccessTest(convert);
+});
+
+test("convert rejects when execFile fails", async () => {
+  await runConvertFailTest(convert);
+});
+
+test("convert logs stderr when present", async () => {
+  await runConvertLogsStderror(convert);
+});

From c0f0dc5192cf822190544e9aa6576fad61abbd44 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 18:20:46 +0200
Subject: [PATCH 19/30] test: add optional options parameter to ExecFileFn type

---
 src/converters/types.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/converters/types.ts b/src/converters/types.ts
index 5d7dc9f..5227b37 100644
--- a/src/converters/types.ts
+++ b/src/converters/types.ts
@@ -1,6 +1,7 @@
 export type ExecFileFn = (
   cmd: string,
   args: string[],
+  options: import("child_process").ExecFileOptions | undefined,
   callback: (err: Error | null, stdout: string, stderr: string) => void,
 ) => void;
 

From 08a833f1cfb9710c9d197837d8c3c2be1f53a2d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 18:38:21 +0200
Subject: [PATCH 20/30] test: add parameter options to usage of type ExecFileFn

---
 src/converters/assimp.ts               |  2 +-
 src/converters/calibre.ts              |  2 +-
 src/converters/dvisvgm.ts              | 29 +++++++++++++++-----------
 src/converters/ffmpeg.ts               |  1 +
 src/converters/graphicsmagick.ts       |  2 +-
 src/converters/imagemagick.ts          |  1 +
 src/converters/inkscape.ts             |  2 +-
 src/converters/libheif.ts              |  2 +-
 src/converters/libjxl.ts               |  2 +-
 src/converters/libreoffice.ts          |  7 ++++---
 src/converters/pandoc.ts               |  7 ++++---
 src/converters/potrace.ts              | 29 +++++++++++++++-----------
 src/converters/resvg.ts                |  2 +-
 src/converters/types.ts                |  2 +-
 src/converters/vips.ts                 |  2 +-
 src/converters/xelatex.ts              |  1 +
 tests/converters/dvisvgm.test.ts       |  3 +++
 tests/converters/ffmpeg.test.ts        |  1 +
 tests/converters/helpers/converters.ts |  7 +++++--
 tests/converters/imagemagick.test.ts   |  4 ++++
 tests/converters/libjxl.test.ts        |  2 ++
 tests/converters/vips.test.ts          |  2 ++
 22 files changed, 71 insertions(+), 41 deletions(-)

diff --git a/src/converters/assimp.ts b/src/converters/assimp.ts
index 869f28e..08223ea 100644
--- a/src/converters/assimp.ts
+++ b/src/converters/assimp.ts
@@ -121,7 +121,7 @@ export async function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("assimp", ["export", filePath, targetPath], (error, stdout, stderr) => {
+    execFile("assimp", ["export", filePath, targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/calibre.ts b/src/converters/calibre.ts
index 153de16..bf63a27 100644
--- a/src/converters/calibre.ts
+++ b/src/converters/calibre.ts
@@ -67,7 +67,7 @@ export async function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("ebook-convert", [filePath, targetPath], (error, stdout, stderr) => {
+    execFile("ebook-convert", [filePath, targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/dvisvgm.ts b/src/converters/dvisvgm.ts
index 76ef5c1..e7e422f 100644
--- a/src/converters/dvisvgm.ts
+++ b/src/converters/dvisvgm.ts
@@ -30,20 +30,25 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile("dvisvgm", [...inputArgs, filePath, "-o", targetPath], (error, stdout, stderr) => {
-      if (error) {
-        reject(`error: ${error}`);
-      }
+    execFile(
+      "dvisvgm",
+      [...inputArgs, filePath, "-o", targetPath],
+      options,
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(`error: ${error}`);
+        }
 
-      if (stdout) {
-        console.log(`stdout: ${stdout}`);
-      }
+        if (stdout) {
+          console.log(`stdout: ${stdout}`);
+        }
 
-      if (stderr) {
-        console.error(`stderr: ${stderr}`);
-      }
+        if (stderr) {
+          console.error(`stderr: ${stderr}`);
+        }
 
-      resolve("Done");
-    });
+        resolve("Done");
+      },
+    );
   });
 }
diff --git a/src/converters/ffmpeg.ts b/src/converters/ffmpeg.ts
index 8207c61..3e0cab7 100644
--- a/src/converters/ffmpeg.ts
+++ b/src/converters/ffmpeg.ts
@@ -735,6 +735,7 @@ export async function convert(
     execFile(
       "ffmpeg",
       [...ffmpegArgs, "-i", filePath, ...extraArgs, targetPath],
+      options,
       (error, stdout, stderr) => {
         if (error) {
           reject(`error: ${error}`);
diff --git a/src/converters/graphicsmagick.ts b/src/converters/graphicsmagick.ts
index 5551341..7d234e7 100644
--- a/src/converters/graphicsmagick.ts
+++ b/src/converters/graphicsmagick.ts
@@ -318,7 +318,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("gm", ["convert", filePath, targetPath], (error, stdout, stderr) => {
+    execFile("gm", ["convert", filePath, targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/imagemagick.ts b/src/converters/imagemagick.ts
index eb2eaa7..28b1ef5 100644
--- a/src/converters/imagemagick.ts
+++ b/src/converters/imagemagick.ts
@@ -472,6 +472,7 @@ export function convert(
     execFile(
       "magick",
       [...inputArgs, filePath, ...outputArgs, targetPath],
+      options,
       (error, stdout, stderr) => {
         if (error) {
           reject(`error: ${error}`);
diff --git a/src/converters/inkscape.ts b/src/converters/inkscape.ts
index 4497e2f..4d277bd 100644
--- a/src/converters/inkscape.ts
+++ b/src/converters/inkscape.ts
@@ -37,7 +37,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("inkscape", [filePath, "-o", targetPath], (error, stdout, stderr) => {
+    execFile("inkscape", [filePath, "-o", targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/libheif.ts b/src/converters/libheif.ts
index b88e177..6326662 100644
--- a/src/converters/libheif.ts
+++ b/src/converters/libheif.ts
@@ -19,7 +19,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("heif-convert", [filePath, targetPath], (error, stdout, stderr) => {
+    execFile("heif-convert", [filePath, targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/libjxl.ts b/src/converters/libjxl.ts
index 6ff825f..cd7f315 100644
--- a/src/converters/libjxl.ts
+++ b/src/converters/libjxl.ts
@@ -31,7 +31,7 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile(tool, [filePath, targetPath], (error, stdout, stderr) => {
+    execFile(tool, [filePath, targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/libreoffice.ts b/src/converters/libreoffice.ts
index d5c47af..7489a91 100644
--- a/src/converters/libreoffice.ts
+++ b/src/converters/libreoffice.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -136,8 +137,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   const outputPath = targetPath.split("/").slice(0, -1).join("/").replace("./", "") ?? targetPath;
 
@@ -157,7 +158,7 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile("soffice", args, (error, stdout, stderr) => {
+    execFile("soffice", args, options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/pandoc.ts b/src/converters/pandoc.ts
index 6aab79d..3873454 100644
--- a/src/converters/pandoc.ts
+++ b/src/converters/pandoc.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -124,8 +125,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   // set xelatex here
   const xelatex = ["pdf", "latex"];
@@ -143,7 +144,7 @@ export function convert(
   args.push("-o", targetPath);
 
   return new Promise((resolve, reject) => {
-    execFile("pandoc", args, (error, stdout, stderr) => {
+    execFile("pandoc", args, options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/potrace.ts b/src/converters/potrace.ts
index 6027491..767fee0 100644
--- a/src/converters/potrace.ts
+++ b/src/converters/potrace.ts
@@ -31,20 +31,25 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("potrace", [filePath, "-o", targetPath, "-b", convertTo], (error, stdout, stderr) => {
-      if (error) {
-        reject(`error: ${error}`);
-      }
+    execFile(
+      "potrace",
+      [filePath, "-o", targetPath, "-b", convertTo],
+      options,
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(`error: ${error}`);
+        }
 
-      if (stdout) {
-        console.log(`stdout: ${stdout}`);
-      }
+        if (stdout) {
+          console.log(`stdout: ${stdout}`);
+        }
 
-      if (stderr) {
-        console.error(`stderr: ${stderr}`);
-      }
+        if (stderr) {
+          console.error(`stderr: ${stderr}`);
+        }
 
-      resolve("Done");
-    });
+        resolve("Done");
+      },
+    );
   });
 }
diff --git a/src/converters/resvg.ts b/src/converters/resvg.ts
index 3155483..97062cc 100644
--- a/src/converters/resvg.ts
+++ b/src/converters/resvg.ts
@@ -19,7 +19,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("resvg", [filePath, targetPath], (error, stdout, stderr) => {
+    execFile("resvg", [filePath, targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/types.ts b/src/converters/types.ts
index 5227b37..0f265b6 100644
--- a/src/converters/types.ts
+++ b/src/converters/types.ts
@@ -1,7 +1,7 @@
 export type ExecFileFn = (
   cmd: string,
   args: string[],
-  options: import("child_process").ExecFileOptions | undefined,
+  options: import("child_process").ExecFileOptions | unknown | undefined | null,
   callback: (err: Error | null, stdout: string, stderr: string) => void,
 ) => void;
 
diff --git a/src/converters/vips.ts b/src/converters/vips.ts
index b89db12..ddab269 100644
--- a/src/converters/vips.ts
+++ b/src/converters/vips.ts
@@ -120,7 +120,7 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile("vips", [action, filePath, targetPath], (error, stdout, stderr) => {
+    execFile("vips", [action, filePath, targetPath], options, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/xelatex.ts b/src/converters/xelatex.ts
index 784acdc..a940fdf 100644
--- a/src/converters/xelatex.ts
+++ b/src/converters/xelatex.ts
@@ -25,6 +25,7 @@ export function convert(
     execFile(
       "latexmk",
       ["-xelatex", "-interaction=nonstopmode", `-output-directory=${outputPath}`, filePath],
+      options,
       (error, stdout, stderr) => {
         if (error) {
           reject(`error: ${error}`);
diff --git a/tests/converters/dvisvgm.test.ts b/tests/converters/dvisvgm.test.ts
index 873b4db..2c91a2f 100644
--- a/tests/converters/dvisvgm.test.ts
+++ b/tests/converters/dvisvgm.test.ts
@@ -37,6 +37,7 @@ test("convert respects eps filetype", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -63,6 +64,7 @@ test("convert respects pdf filetype", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -89,6 +91,7 @@ test("convert respects svgz conversion target type", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
diff --git a/tests/converters/ffmpeg.test.ts b/tests/converters/ffmpeg.test.ts
index 2bb375a..4cea0ea 100644
--- a/tests/converters/ffmpeg.test.ts
+++ b/tests/converters/ffmpeg.test.ts
@@ -6,6 +6,7 @@ let calls: string[][] = [];
 function mockExecFile(
   _cmd: string,
   args: string[],
+  options: unknown,
   callback: (err: Error | null, stdout: string, stderr: string) => void,
 ) {
   calls.push(args);
diff --git a/tests/converters/helpers/converters.ts b/tests/converters/helpers/converters.ts
index fe04d7e..950c873 100644
--- a/tests/converters/helpers/converters.ts
+++ b/tests/converters/helpers/converters.ts
@@ -13,6 +13,7 @@ export async function runConvertSuccessTest(convertFn: ConvertFnWithExecFile) {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     callback(null, "Fake stdout", "");
@@ -30,6 +31,7 @@ export async function runConvertFailTest(convertFn: ConvertFnWithExecFile) {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     callback(new Error("Test error"), "", "");
@@ -51,9 +53,10 @@ export async function runConvertLogsStderror(convertFn: ConvertFnWithExecFile) {
   const mockExecFile = (
     _cmd: string,
     _args: string[],
-    cb: (err: Error | null, stdout: string, stderr: string) => void,
+    options: unknown,
+    callback: (err: Error | null, stdout: string, stderr: string) => void,
   ) => {
-    cb(null, "", "Fake stderr");
+    callback(null, "", "Fake stderr");
   };
 
   await convertFn("file.obj", "obj", "stl", "out.stl", undefined, mockExecFile);
diff --git a/tests/converters/imagemagick.test.ts b/tests/converters/imagemagick.test.ts
index 26ec4a9..06f1d13 100644
--- a/tests/converters/imagemagick.test.ts
+++ b/tests/converters/imagemagick.test.ts
@@ -37,6 +37,7 @@ test("convert respects ico conversion target type", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -72,6 +73,7 @@ test("convert respects ico conversion target type with svg as input filetype", a
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -109,6 +111,7 @@ test("convert respects ico conversion target type with emf as input filetype", a
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -150,6 +153,7 @@ test("convert respects emf as input filetype", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
diff --git a/tests/converters/libjxl.test.ts b/tests/converters/libjxl.test.ts
index cea851b..ed352d6 100644
--- a/tests/converters/libjxl.test.ts
+++ b/tests/converters/libjxl.test.ts
@@ -37,6 +37,7 @@ test("convert uses djxl with input filetype being jxl", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     command = _cmd;
@@ -63,6 +64,7 @@ test("convert uses cjxl with output filetype being jxl", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     command = _cmd;
diff --git a/tests/converters/vips.test.ts b/tests/converters/vips.test.ts
index dec12dd..d7ea9d8 100644
--- a/tests/converters/vips.test.ts
+++ b/tests/converters/vips.test.ts
@@ -37,6 +37,7 @@ test("convert uses action pdfload with filetype being pdf", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -63,6 +64,7 @@ test("convert uses action copy with filetype being anything but pdf", async () =
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
+    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);

From 4b42a5fbda25d80a6923c63b6e2685120c6973ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 18:47:20 +0200
Subject: [PATCH 21/30] test: add test if stderror and stdout get logged if
 both are present

---
 tests/converters/assimp.test.ts         |  5 ++++
 tests/converters/calibre.test.ts        |  5 ++++
 tests/converters/dvisvgm.test.ts        |  5 ++++
 tests/converters/graphicsmagick.test.ts |  5 ++++
 tests/converters/helpers/converters.ts  | 31 +++++++++++++++++++++++++
 tests/converters/imagemagick.test.ts    |  5 ++++
 tests/converters/inkscape.test.ts       |  5 ++++
 tests/converters/libheif.test.ts        |  5 ++++
 tests/converters/libjxl.test.ts         |  5 ++++
 tests/converters/potrace.test.ts        |  5 ++++
 tests/converters/resvg.test.ts          |  5 ++++
 tests/converters/vips.test.ts           |  5 ++++
 tests/converters/xelatex.test.ts        |  5 ++++
 13 files changed, 91 insertions(+)

diff --git a/tests/converters/assimp.test.ts b/tests/converters/assimp.test.ts
index 01ba0ad..c7052fc 100644
--- a/tests/converters/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/assimp.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
diff --git a/tests/converters/calibre.test.ts b/tests/converters/calibre.test.ts
index d060097..41fea53 100644
--- a/tests/converters/calibre.test.ts
+++ b/tests/converters/calibre.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/calibre.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
diff --git a/tests/converters/dvisvgm.test.ts b/tests/converters/dvisvgm.test.ts
index 2c91a2f..b7211e4 100644
--- a/tests/converters/dvisvgm.test.ts
+++ b/tests/converters/dvisvgm.test.ts
@@ -5,6 +5,7 @@ import { ExecFileFn } from "../../src/converters/types.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -26,6 +27,10 @@ test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
 
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
+
 test("convert respects eps filetype", async () => {
   const originalConsoleLog = console.log;
 
diff --git a/tests/converters/graphicsmagick.test.ts b/tests/converters/graphicsmagick.test.ts
index df9bda8..8c038e2 100644
--- a/tests/converters/graphicsmagick.test.ts
+++ b/tests/converters/graphicsmagick.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/graphicsmagick.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
diff --git a/tests/converters/helpers/converters.ts b/tests/converters/helpers/converters.ts
index 950c873..02aa084 100644
--- a/tests/converters/helpers/converters.ts
+++ b/tests/converters/helpers/converters.ts
@@ -65,3 +65,34 @@ export async function runConvertLogsStderror(convertFn: ConvertFnWithExecFile) {
 
   expect(loggedMessage).toBe("stderr: Fake stderr");
 }
+
+export async function runConvertLogsStderrorAndStdout(convertFn: ConvertFnWithExecFile) {
+  const originalConsoleError = console.error;
+  const originalConsoleLog = console.log;
+
+  let loggedError = "";
+  let loggedMessage = "";
+  console.error = (msg) => {
+    loggedError = msg;
+  };
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile = (
+    _cmd: string,
+    _args: string[],
+    options: unknown,
+    callback: (err: Error | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "Fake stdout", "Fake stderr");
+  };
+
+  await convertFn("file.obj", "obj", "stl", "out.stl", undefined, mockExecFile);
+
+  console.error = originalConsoleError;
+  console.log = originalConsoleLog;
+
+  expect(loggedError).toBe("stderr: Fake stderr");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+}
diff --git a/tests/converters/imagemagick.test.ts b/tests/converters/imagemagick.test.ts
index 06f1d13..de2467c 100644
--- a/tests/converters/imagemagick.test.ts
+++ b/tests/converters/imagemagick.test.ts
@@ -5,6 +5,7 @@ import { ExecFileFn } from "../../src/converters/types.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -26,6 +27,10 @@ test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
 
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
+
 test("convert respects ico conversion target type", async () => {
   const originalConsoleLog = console.log;
 
diff --git a/tests/converters/inkscape.test.ts b/tests/converters/inkscape.test.ts
index 39d21c3..f61746e 100644
--- a/tests/converters/inkscape.test.ts
+++ b/tests/converters/inkscape.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/inkscape.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
diff --git a/tests/converters/libheif.test.ts b/tests/converters/libheif.test.ts
index 33625c5..267734d 100644
--- a/tests/converters/libheif.test.ts
+++ b/tests/converters/libheif.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/libheif.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
diff --git a/tests/converters/libjxl.test.ts b/tests/converters/libjxl.test.ts
index ed352d6..e96c5f8 100644
--- a/tests/converters/libjxl.test.ts
+++ b/tests/converters/libjxl.test.ts
@@ -5,6 +5,7 @@ import { ExecFileFn } from "../../src/converters/types.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -26,6 +27,10 @@ test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
 
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
+
 test("convert uses djxl with input filetype being jxl", async () => {
   const originalConsoleLog = console.log;
 
diff --git a/tests/converters/potrace.test.ts b/tests/converters/potrace.test.ts
index 5f37450..f1852a7 100644
--- a/tests/converters/potrace.test.ts
+++ b/tests/converters/potrace.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/potrace.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
diff --git a/tests/converters/resvg.test.ts b/tests/converters/resvg.test.ts
index d2eae2f..cdcb6b9 100644
--- a/tests/converters/resvg.test.ts
+++ b/tests/converters/resvg.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/resvg.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
diff --git a/tests/converters/vips.test.ts b/tests/converters/vips.test.ts
index d7ea9d8..2aa2181 100644
--- a/tests/converters/vips.test.ts
+++ b/tests/converters/vips.test.ts
@@ -5,6 +5,7 @@ import { convert } from "../../src/converters/vips.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -26,6 +27,10 @@ test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
 
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});
+
 test("convert uses action pdfload with filetype being pdf", async () => {
   const originalConsoleLog = console.log;
 
diff --git a/tests/converters/xelatex.test.ts b/tests/converters/xelatex.test.ts
index 5d81d09..5794b70 100644
--- a/tests/converters/xelatex.test.ts
+++ b/tests/converters/xelatex.test.ts
@@ -3,6 +3,7 @@ import { convert } from "../../src/converters/xelatex.ts";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
 } from "./helpers/converters.ts";
 
@@ -17,3 +18,7 @@ test("convert rejects when execFile fails", async () => {
 test("convert logs stderr when present", async () => {
   await runConvertLogsStderror(convert);
 });
+
+test("convert logs both stderr and stdout when present", async () => {
+  await runConvertLogsStderrorAndStdout(convert);
+});

From e5ac60c1872e07a0420f6a0f68fd20dc9761de5f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 19:19:07 +0200
Subject: [PATCH 22/30] test: add unit test for msgconvert.ts

---
 src/converters/msgconvert.ts        | 19 ++++++---
 tests/converters/msgconvert.test.ts | 64 +++++++++++++++++++++++++++++
 2 files changed, 77 insertions(+), 6 deletions(-)
 create mode 100644 tests/converters/msgconvert.test.ts

diff --git a/src/converters/msgconvert.ts b/src/converters/msgconvert.ts
index b6bf826..cfd0d62 100644
--- a/src/converters/msgconvert.ts
+++ b/src/converters/msgconvert.ts
@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile as execFileOriginal } from "node:child_process";
+import { ExecFileFn } from "./types.ts";
 
 export const properties = {
   from: {
@@ -14,8 +15,8 @@ export function convert(
   fileType: string,
   convertTo: string,
   targetPath: string,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   options?: unknown,
+  execFile: ExecFileFn = execFileOriginal,
 ): Promise<string> {
   return new Promise((resolve, reject) => {
     if (fileType === "msg" && convertTo === "eml") {
@@ -23,8 +24,8 @@ export function convert(
       // msgconvert will output to the same directory as the input file with .eml extension
       // We need to use --outfile to specify the target path
       const args = ["--outfile", targetPath, filePath];
-      
-      execFile("msgconvert", args, (error, stdout, stderr) => {
+
+      execFile("msgconvert", args, options, (error, stdout, stderr) => {
         if (error) {
           reject(new Error(`msgconvert failed: ${error.message}`));
           return;
@@ -33,13 +34,19 @@ export function convert(
         if (stderr) {
           // Log sanitized stderr to avoid exposing sensitive paths
           const sanitizedStderr = stderr.replace(/(\/[^\s]+)/g, "[REDACTED_PATH]");
-          console.warn(`msgconvert stderr: ${sanitizedStderr.length > 200 ? sanitizedStderr.slice(0, 200) + '...' : sanitizedStderr}`);
+          console.warn(
+            `msgconvert stderr: ${sanitizedStderr.length > 200 ? sanitizedStderr.slice(0, 200) + "..." : sanitizedStderr}`,
+          );
         }
 
         resolve(targetPath);
       });
     } else {
-      reject(new Error(`Unsupported conversion from ${fileType} to ${convertTo}. Only MSG to EML conversion is currently supported.`));
+      reject(
+        new Error(
+          `Unsupported conversion from ${fileType} to ${convertTo}. Only MSG to EML conversion is currently supported.`,
+        ),
+      );
     }
   });
 }
diff --git a/tests/converters/msgconvert.test.ts b/tests/converters/msgconvert.test.ts
new file mode 100644
index 0000000..8b8c155
--- /dev/null
+++ b/tests/converters/msgconvert.test.ts
@@ -0,0 +1,64 @@
+import type { ExecFileException } from "node:child_process";
+import { expect, test } from "bun:test";
+import { convert } from "../../src/converters/msgconvert.ts";
+import { ExecFileFn } from "../../src/converters/types.ts";
+
+test("convert rejects conversion if input filetype is not msg and output type is not eml", async () => {
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    options: unknown,
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "Fake stdout", "");
+  };
+
+  const expectedError = new Error(
+    "Unsupported conversion from obj to stl. Only MSG to EML conversion is currently supported.",
+  );
+
+  expect(convert("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile)).rejects.toEqual(
+    expectedError,
+  );
+});
+
+test("convert rejects conversion on error", async () => {
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    options: unknown,
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(new Error("Test error"), "", "");
+  };
+
+  const expectedError = new Error("msgconvert failed: Test error")
+
+  expect(
+    convert("input.msg", "msg", "eml", "output.eml", undefined, mockExecFile),
+  ).rejects.toEqual(expectedError);
+})
+
+test("convert logs stderr as warning", async () => {
+  const originalConsoleWarn = console.warn;
+
+  let loggedMessage = "";
+  console.warn = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile = (
+    _cmd: string,
+    _args: string[],
+    options: unknown,
+    callback: (err: Error | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "", "Fake stderr");
+  };
+
+  await convert("file.msg", "msg", "eml", "out.eml", undefined, mockExecFile);
+
+  console.error = originalConsoleWarn;
+
+  expect(loggedMessage).toBe("msgconvert stderr: Fake stderr");
+})

From eac22d53d3416b95499ba014c9be7cef30cff5db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 19:19:46 +0200
Subject: [PATCH 23/30] test: prettify test for msgconvert.ts

---
 tests/converters/msgconvert.test.ts | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/converters/msgconvert.test.ts b/tests/converters/msgconvert.test.ts
index 8b8c155..ab054f7 100644
--- a/tests/converters/msgconvert.test.ts
+++ b/tests/converters/msgconvert.test.ts
@@ -32,12 +32,12 @@ test("convert rejects conversion on error", async () => {
     callback(new Error("Test error"), "", "");
   };
 
-  const expectedError = new Error("msgconvert failed: Test error")
+  const expectedError = new Error("msgconvert failed: Test error");
 
-  expect(
-    convert("input.msg", "msg", "eml", "output.eml", undefined, mockExecFile),
-  ).rejects.toEqual(expectedError);
-})
+  expect(convert("input.msg", "msg", "eml", "output.eml", undefined, mockExecFile)).rejects.toEqual(
+    expectedError,
+  );
+});
 
 test("convert logs stderr as warning", async () => {
   const originalConsoleWarn = console.warn;
@@ -61,4 +61,4 @@ test("convert logs stderr as warning", async () => {
   console.error = originalConsoleWarn;
 
   expect(loggedMessage).toBe("msgconvert stderr: Fake stderr");
-})
+});

From af684984947e2d59b8a2f170f44d76f85b90c8d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 19:33:55 +0200
Subject: [PATCH 24/30] test: change order of parameters in ExecFileFn type

---
 src/converters/assimp.ts               |  2 +-
 src/converters/calibre.ts              |  2 +-
 src/converters/dvisvgm.ts              | 29 +++++++++++---------------
 src/converters/ffmpeg.ts               |  1 -
 src/converters/graphicsmagick.ts       |  2 +-
 src/converters/imagemagick.ts          |  1 -
 src/converters/inkscape.ts             |  2 +-
 src/converters/libheif.ts              |  2 +-
 src/converters/libjxl.ts               |  2 +-
 src/converters/libreoffice.ts          |  2 +-
 src/converters/msgconvert.ts           |  2 +-
 src/converters/pandoc.ts               |  2 +-
 src/converters/potrace.ts              | 29 +++++++++++---------------
 src/converters/resvg.ts                |  2 +-
 src/converters/types.ts                |  2 +-
 src/converters/vips.ts                 |  2 +-
 src/converters/xelatex.ts              |  1 -
 tests/converters/dvisvgm.test.ts       |  3 ---
 tests/converters/ffmpeg.test.ts        |  1 -
 tests/converters/helpers/converters.ts |  4 ----
 tests/converters/imagemagick.test.ts   |  4 ----
 tests/converters/libjxl.test.ts        |  2 --
 tests/converters/msgconvert.test.ts    |  3 ---
 tests/converters/vips.test.ts          |  2 --
 24 files changed, 36 insertions(+), 68 deletions(-)

diff --git a/src/converters/assimp.ts b/src/converters/assimp.ts
index 08223ea..869f28e 100644
--- a/src/converters/assimp.ts
+++ b/src/converters/assimp.ts
@@ -121,7 +121,7 @@ export async function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("assimp", ["export", filePath, targetPath], options, (error, stdout, stderr) => {
+    execFile("assimp", ["export", filePath, targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/calibre.ts b/src/converters/calibre.ts
index bf63a27..153de16 100644
--- a/src/converters/calibre.ts
+++ b/src/converters/calibre.ts
@@ -67,7 +67,7 @@ export async function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("ebook-convert", [filePath, targetPath], options, (error, stdout, stderr) => {
+    execFile("ebook-convert", [filePath, targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/dvisvgm.ts b/src/converters/dvisvgm.ts
index e7e422f..76ef5c1 100644
--- a/src/converters/dvisvgm.ts
+++ b/src/converters/dvisvgm.ts
@@ -30,25 +30,20 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile(
-      "dvisvgm",
-      [...inputArgs, filePath, "-o", targetPath],
-      options,
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(`error: ${error}`);
-        }
+    execFile("dvisvgm", [...inputArgs, filePath, "-o", targetPath], (error, stdout, stderr) => {
+      if (error) {
+        reject(`error: ${error}`);
+      }
 
-        if (stdout) {
-          console.log(`stdout: ${stdout}`);
-        }
+      if (stdout) {
+        console.log(`stdout: ${stdout}`);
+      }
 
-        if (stderr) {
-          console.error(`stderr: ${stderr}`);
-        }
+      if (stderr) {
+        console.error(`stderr: ${stderr}`);
+      }
 
-        resolve("Done");
-      },
-    );
+      resolve("Done");
+    });
   });
 }
diff --git a/src/converters/ffmpeg.ts b/src/converters/ffmpeg.ts
index 3e0cab7..8207c61 100644
--- a/src/converters/ffmpeg.ts
+++ b/src/converters/ffmpeg.ts
@@ -735,7 +735,6 @@ export async function convert(
     execFile(
       "ffmpeg",
       [...ffmpegArgs, "-i", filePath, ...extraArgs, targetPath],
-      options,
       (error, stdout, stderr) => {
         if (error) {
           reject(`error: ${error}`);
diff --git a/src/converters/graphicsmagick.ts b/src/converters/graphicsmagick.ts
index 7d234e7..5551341 100644
--- a/src/converters/graphicsmagick.ts
+++ b/src/converters/graphicsmagick.ts
@@ -318,7 +318,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("gm", ["convert", filePath, targetPath], options, (error, stdout, stderr) => {
+    execFile("gm", ["convert", filePath, targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/imagemagick.ts b/src/converters/imagemagick.ts
index 28b1ef5..eb2eaa7 100644
--- a/src/converters/imagemagick.ts
+++ b/src/converters/imagemagick.ts
@@ -472,7 +472,6 @@ export function convert(
     execFile(
       "magick",
       [...inputArgs, filePath, ...outputArgs, targetPath],
-      options,
       (error, stdout, stderr) => {
         if (error) {
           reject(`error: ${error}`);
diff --git a/src/converters/inkscape.ts b/src/converters/inkscape.ts
index 4d277bd..4497e2f 100644
--- a/src/converters/inkscape.ts
+++ b/src/converters/inkscape.ts
@@ -37,7 +37,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("inkscape", [filePath, "-o", targetPath], options, (error, stdout, stderr) => {
+    execFile("inkscape", [filePath, "-o", targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/libheif.ts b/src/converters/libheif.ts
index 6326662..b88e177 100644
--- a/src/converters/libheif.ts
+++ b/src/converters/libheif.ts
@@ -19,7 +19,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("heif-convert", [filePath, targetPath], options, (error, stdout, stderr) => {
+    execFile("heif-convert", [filePath, targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/libjxl.ts b/src/converters/libjxl.ts
index cd7f315..6ff825f 100644
--- a/src/converters/libjxl.ts
+++ b/src/converters/libjxl.ts
@@ -31,7 +31,7 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile(tool, [filePath, targetPath], options, (error, stdout, stderr) => {
+    execFile(tool, [filePath, targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/libreoffice.ts b/src/converters/libreoffice.ts
index 7489a91..73249dc 100644
--- a/src/converters/libreoffice.ts
+++ b/src/converters/libreoffice.ts
@@ -158,7 +158,7 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile("soffice", args, options, (error, stdout, stderr) => {
+    execFile("soffice", args, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/msgconvert.ts b/src/converters/msgconvert.ts
index cfd0d62..0c0b663 100644
--- a/src/converters/msgconvert.ts
+++ b/src/converters/msgconvert.ts
@@ -25,7 +25,7 @@ export function convert(
       // We need to use --outfile to specify the target path
       const args = ["--outfile", targetPath, filePath];
 
-      execFile("msgconvert", args, options, (error, stdout, stderr) => {
+      execFile("msgconvert", args, (error, stdout, stderr) => {
         if (error) {
           reject(new Error(`msgconvert failed: ${error.message}`));
           return;
diff --git a/src/converters/pandoc.ts b/src/converters/pandoc.ts
index 3873454..e5b1db1 100644
--- a/src/converters/pandoc.ts
+++ b/src/converters/pandoc.ts
@@ -144,7 +144,7 @@ export function convert(
   args.push("-o", targetPath);
 
   return new Promise((resolve, reject) => {
-    execFile("pandoc", args, options, (error, stdout, stderr) => {
+    execFile("pandoc", args, (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/potrace.ts b/src/converters/potrace.ts
index 767fee0..6027491 100644
--- a/src/converters/potrace.ts
+++ b/src/converters/potrace.ts
@@ -31,25 +31,20 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile(
-      "potrace",
-      [filePath, "-o", targetPath, "-b", convertTo],
-      options,
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(`error: ${error}`);
-        }
+    execFile("potrace", [filePath, "-o", targetPath, "-b", convertTo], (error, stdout, stderr) => {
+      if (error) {
+        reject(`error: ${error}`);
+      }
 
-        if (stdout) {
-          console.log(`stdout: ${stdout}`);
-        }
+      if (stdout) {
+        console.log(`stdout: ${stdout}`);
+      }
 
-        if (stderr) {
-          console.error(`stderr: ${stderr}`);
-        }
+      if (stderr) {
+        console.error(`stderr: ${stderr}`);
+      }
 
-        resolve("Done");
-      },
-    );
+      resolve("Done");
+    });
   });
 }
diff --git a/src/converters/resvg.ts b/src/converters/resvg.ts
index 97062cc..3155483 100644
--- a/src/converters/resvg.ts
+++ b/src/converters/resvg.ts
@@ -19,7 +19,7 @@ export function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("resvg", [filePath, targetPath], options, (error, stdout, stderr) => {
+    execFile("resvg", [filePath, targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/types.ts b/src/converters/types.ts
index 0f265b6..2c1b649 100644
--- a/src/converters/types.ts
+++ b/src/converters/types.ts
@@ -1,8 +1,8 @@
 export type ExecFileFn = (
   cmd: string,
   args: string[],
-  options: import("child_process").ExecFileOptions | unknown | undefined | null,
   callback: (err: Error | null, stdout: string, stderr: string) => void,
+  options?: import("child_process").ExecFileOptions,
 ) => void;
 
 export type ConvertFnWithExecFile = (
diff --git a/src/converters/vips.ts b/src/converters/vips.ts
index ddab269..b89db12 100644
--- a/src/converters/vips.ts
+++ b/src/converters/vips.ts
@@ -120,7 +120,7 @@ export function convert(
   }
 
   return new Promise((resolve, reject) => {
-    execFile("vips", [action, filePath, targetPath], options, (error, stdout, stderr) => {
+    execFile("vips", [action, filePath, targetPath], (error, stdout, stderr) => {
       if (error) {
         reject(`error: ${error}`);
       }
diff --git a/src/converters/xelatex.ts b/src/converters/xelatex.ts
index a940fdf..784acdc 100644
--- a/src/converters/xelatex.ts
+++ b/src/converters/xelatex.ts
@@ -25,7 +25,6 @@ export function convert(
     execFile(
       "latexmk",
       ["-xelatex", "-interaction=nonstopmode", `-output-directory=${outputPath}`, filePath],
-      options,
       (error, stdout, stderr) => {
         if (error) {
           reject(`error: ${error}`);
diff --git a/tests/converters/dvisvgm.test.ts b/tests/converters/dvisvgm.test.ts
index b7211e4..c24d545 100644
--- a/tests/converters/dvisvgm.test.ts
+++ b/tests/converters/dvisvgm.test.ts
@@ -42,7 +42,6 @@ test("convert respects eps filetype", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -69,7 +68,6 @@ test("convert respects pdf filetype", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -96,7 +94,6 @@ test("convert respects svgz conversion target type", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
diff --git a/tests/converters/ffmpeg.test.ts b/tests/converters/ffmpeg.test.ts
index 4cea0ea..2bb375a 100644
--- a/tests/converters/ffmpeg.test.ts
+++ b/tests/converters/ffmpeg.test.ts
@@ -6,7 +6,6 @@ let calls: string[][] = [];
 function mockExecFile(
   _cmd: string,
   args: string[],
-  options: unknown,
   callback: (err: Error | null, stdout: string, stderr: string) => void,
 ) {
   calls.push(args);
diff --git a/tests/converters/helpers/converters.ts b/tests/converters/helpers/converters.ts
index 02aa084..49a40ac 100644
--- a/tests/converters/helpers/converters.ts
+++ b/tests/converters/helpers/converters.ts
@@ -13,7 +13,6 @@ export async function runConvertSuccessTest(convertFn: ConvertFnWithExecFile) {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     callback(null, "Fake stdout", "");
@@ -31,7 +30,6 @@ export async function runConvertFailTest(convertFn: ConvertFnWithExecFile) {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     callback(new Error("Test error"), "", "");
@@ -53,7 +51,6 @@ export async function runConvertLogsStderror(convertFn: ConvertFnWithExecFile) {
   const mockExecFile = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: Error | null, stdout: string, stderr: string) => void,
   ) => {
     callback(null, "", "Fake stderr");
@@ -82,7 +79,6 @@ export async function runConvertLogsStderrorAndStdout(convertFn: ConvertFnWithEx
   const mockExecFile = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: Error | null, stdout: string, stderr: string) => void,
   ) => {
     callback(null, "Fake stdout", "Fake stderr");
diff --git a/tests/converters/imagemagick.test.ts b/tests/converters/imagemagick.test.ts
index de2467c..482d87c 100644
--- a/tests/converters/imagemagick.test.ts
+++ b/tests/converters/imagemagick.test.ts
@@ -42,7 +42,6 @@ test("convert respects ico conversion target type", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -78,7 +77,6 @@ test("convert respects ico conversion target type with svg as input filetype", a
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -116,7 +114,6 @@ test("convert respects ico conversion target type with emf as input filetype", a
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -158,7 +155,6 @@ test("convert respects emf as input filetype", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
diff --git a/tests/converters/libjxl.test.ts b/tests/converters/libjxl.test.ts
index e96c5f8..7caf0bb 100644
--- a/tests/converters/libjxl.test.ts
+++ b/tests/converters/libjxl.test.ts
@@ -42,7 +42,6 @@ test("convert uses djxl with input filetype being jxl", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     command = _cmd;
@@ -69,7 +68,6 @@ test("convert uses cjxl with output filetype being jxl", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     command = _cmd;
diff --git a/tests/converters/msgconvert.test.ts b/tests/converters/msgconvert.test.ts
index ab054f7..ffdf840 100644
--- a/tests/converters/msgconvert.test.ts
+++ b/tests/converters/msgconvert.test.ts
@@ -7,7 +7,6 @@ test("convert rejects conversion if input filetype is not msg and output type is
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     callback(null, "Fake stdout", "");
@@ -26,7 +25,6 @@ test("convert rejects conversion on error", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     callback(new Error("Test error"), "", "");
@@ -50,7 +48,6 @@ test("convert logs stderr as warning", async () => {
   const mockExecFile = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: Error | null, stdout: string, stderr: string) => void,
   ) => {
     callback(null, "", "Fake stderr");
diff --git a/tests/converters/vips.test.ts b/tests/converters/vips.test.ts
index 2aa2181..010a7a0 100644
--- a/tests/converters/vips.test.ts
+++ b/tests/converters/vips.test.ts
@@ -42,7 +42,6 @@ test("convert uses action pdfload with filetype being pdf", async () => {
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);
@@ -69,7 +68,6 @@ test("convert uses action copy with filetype being anything but pdf", async () =
   const mockExecFile: ExecFileFn = (
     _cmd: string,
     _args: string[],
-    options: unknown,
     callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
   ) => {
     calls.push(_args);

From 9c24cf4aba3162afa1d89b93394ad83925547b2f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 19:37:48 +0200
Subject: [PATCH 25/30] test: add test case to ffmpeg.test.ts

---
 tests/converters/ffmpeg.test.ts | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/tests/converters/ffmpeg.test.ts b/tests/converters/ffmpeg.test.ts
index 2bb375a..01d4633 100644
--- a/tests/converters/ffmpeg.test.ts
+++ b/tests/converters/ffmpeg.test.ts
@@ -155,3 +155,27 @@ test("fails on exec error", async () => {
 
   expect(loggedMessage).toBe("stderr: Fake stderr: fail");
 });
+
+test("logs stderr when execFile returns only stderr and no error", async () => {
+  const originalConsoleError = console.error;
+
+  let loggedMessage = "";
+  console.error = (msg) => {
+    loggedMessage = msg;
+  };
+
+  // Mock execFile to call back with no error, no stdout, but with stderr
+  const mockExecFileStderrOnly = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: Error | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback(null, "", "Only stderr output");
+  };
+
+  await convert("input.mov", "mov", "mp4", "output.mp4", undefined, mockExecFileStderrOnly);
+
+  console.error = originalConsoleError;
+
+  expect(loggedMessage).toBe("stderr: Only stderr output");
+});

From 178f0094587ae2a7dc77c092802d9c6d5b4aab76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 19:46:59 +0200
Subject: [PATCH 26/30] test: extend fail test with different error messages

---
 tests/converters/helpers/converters.ts | 27 ++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/tests/converters/helpers/converters.ts b/tests/converters/helpers/converters.ts
index 49a40ac..f941bc9 100644
--- a/tests/converters/helpers/converters.ts
+++ b/tests/converters/helpers/converters.ts
@@ -38,6 +38,33 @@ export async function runConvertFailTest(convertFn: ConvertFnWithExecFile) {
   expect(
     convertFn("input.obj", "obj", "stl", "output.stl", undefined, mockExecFile),
   ).rejects.toMatch(/error: Error: Test error/);
+
+  // Test with error object lacking 'message' property
+  const mockExecFileNoMessage: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    // Simulate a non-standard error object
+    callback({ notMessage: true } as unknown as ExecFileException, "", "");
+  };
+
+  expect(
+    convertFn("input.obj", "obj", "stl", "output.stl", undefined, mockExecFileNoMessage),
+  ).rejects.toMatch(/error:/i);
+
+  // Test with a non-object error (e.g., a string)
+  const mockExecFileStringError: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    callback("string error" as unknown as ExecFileException, "", "");
+  };
+
+  expect(
+    convertFn("input.obj", "obj", "stl", "output.stl", undefined, mockExecFileStringError),
+  ).rejects.toMatch(/error:/i);
 }
 
 export async function runConvertLogsStderror(convertFn: ConvertFnWithExecFile) {

From c6006b58d23aff7b23b1f1663f9a05c68d227b71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 19:53:22 +0200
Subject: [PATCH 27/30] test: add test case to libjxl.test.ts when input and
 output are not jxl

---
 tests/converters/libjxl.test.ts | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/tests/converters/libjxl.test.ts b/tests/converters/libjxl.test.ts
index 7caf0bb..c591570 100644
--- a/tests/converters/libjxl.test.ts
+++ b/tests/converters/libjxl.test.ts
@@ -82,3 +82,29 @@ test("convert uses cjxl with output filetype being jxl", async () => {
   expect(command).toEqual("cjxl");
   expect(loggedMessage).toBe("stdout: Fake stdout");
 });
+
+test("convert uses empty string as command with neither input nor output filetype being jxl", async () => {
+  const originalConsoleLog = console.log;
+
+  let loggedMessage = "";
+  console.log = (msg) => {
+    loggedMessage = msg;
+  };
+
+  const mockExecFile: ExecFileFn = (
+    _cmd: string,
+    _args: string[],
+    callback: (err: ExecFileException | null, stdout: string, stderr: string) => void,
+  ) => {
+    command = _cmd;
+    callback(null, "Fake stdout", "");
+  };
+
+  const result = await convert("input.png", "png", "jpg", "output.jpg", undefined, mockExecFile);
+
+  console.log = originalConsoleLog;
+
+  expect(result).toBe("Done");
+  expect(command).toEqual("");
+  expect(loggedMessage).toBe("stdout: Fake stdout");
+});

From c0105889abae9498b135a015b20b4396be5c1048 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Thu, 24 Jul 2025 21:08:10 +0200
Subject: [PATCH 28/30] test: extract duplicate code into another helper

---
 tests/converters/assimp.test.ts         | 23 +++-------------------
 tests/converters/calibre.test.ts        | 23 +++-------------------
 tests/converters/dvisvgm.test.ts        | 23 ++--------------------
 tests/converters/graphicsmagick.test.ts | 23 +++-------------------
 tests/converters/helpers/commonTests.ts | 26 +++++++++++++++++++++++++
 tests/converters/imagemagick.test.ts    | 23 ++--------------------
 tests/converters/inkscape.test.ts       | 23 +++-------------------
 tests/converters/libheif.test.ts        | 23 +++-------------------
 tests/converters/libjxl.test.ts         | 23 ++--------------------
 tests/converters/potrace.test.ts        | 23 +++-------------------
 tests/converters/resvg.test.ts          | 23 +++-------------------
 tests/converters/vips.test.ts           | 23 ++--------------------
 tests/converters/xelatex.test.ts        | 23 +++-------------------
 13 files changed, 58 insertions(+), 244 deletions(-)
 create mode 100644 tests/converters/helpers/commonTests.ts

diff --git a/tests/converters/assimp.test.ts b/tests/converters/assimp.test.ts
index c7052fc..e032093 100644
--- a/tests/converters/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/assimp.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});
diff --git a/tests/converters/calibre.test.ts b/tests/converters/calibre.test.ts
index 41fea53..91c1b23 100644
--- a/tests/converters/calibre.test.ts
+++ b/tests/converters/calibre.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/calibre.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});
diff --git a/tests/converters/dvisvgm.test.ts b/tests/converters/dvisvgm.test.ts
index c24d545..a638f13 100644
--- a/tests/converters/dvisvgm.test.ts
+++ b/tests/converters/dvisvgm.test.ts
@@ -2,12 +2,7 @@ import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
 import { convert } from "../../src/converters/dvisvgm.ts";
 import { ExecFileFn } from "../../src/converters/types.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
 let calls: string[][] = [];
 
@@ -15,21 +10,7 @@ beforeEach(() => {
   calls = [];
 });
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
-
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+runCommonTests(convert);
 
 test("convert respects eps filetype", async () => {
   const originalConsoleLog = console.log;
diff --git a/tests/converters/graphicsmagick.test.ts b/tests/converters/graphicsmagick.test.ts
index 8c038e2..625ec0d 100644
--- a/tests/converters/graphicsmagick.test.ts
+++ b/tests/converters/graphicsmagick.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/graphicsmagick.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});
diff --git a/tests/converters/helpers/commonTests.ts b/tests/converters/helpers/commonTests.ts
new file mode 100644
index 0000000..9b6b4f0
--- /dev/null
+++ b/tests/converters/helpers/commonTests.ts
@@ -0,0 +1,26 @@
+import { test } from "bun:test";
+import { ConvertFnWithExecFile } from "../../../src/converters/types.ts";
+import {
+  runConvertFailTest,
+  runConvertLogsStderror,
+  runConvertLogsStderrorAndStdout,
+  runConvertSuccessTest,
+} from "./converters.ts";
+
+export function runCommonTests(convert: ConvertFnWithExecFile) {
+  test("convert resolves when execFile succeeds", async () => {
+    await runConvertSuccessTest(convert);
+  });
+
+  test("convert rejects when execFile fails", async () => {
+    await runConvertFailTest(convert);
+  });
+
+  test("convert logs stderr when present", async () => {
+    await runConvertLogsStderror(convert);
+  });
+
+  test("convert logs both stderr and stdout when present", async () => {
+    await runConvertLogsStderrorAndStdout(convert);
+  });
+}
diff --git a/tests/converters/imagemagick.test.ts b/tests/converters/imagemagick.test.ts
index 482d87c..4916177 100644
--- a/tests/converters/imagemagick.test.ts
+++ b/tests/converters/imagemagick.test.ts
@@ -2,12 +2,7 @@ import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
 import { convert } from "../../src/converters/imagemagick.ts";
 import { ExecFileFn } from "../../src/converters/types.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
 let calls: string[][] = [];
 
@@ -15,21 +10,7 @@ beforeEach(() => {
   calls = [];
 });
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
-
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+runCommonTests(convert);
 
 test("convert respects ico conversion target type", async () => {
   const originalConsoleLog = console.log;
diff --git a/tests/converters/inkscape.test.ts b/tests/converters/inkscape.test.ts
index f61746e..ad15a3b 100644
--- a/tests/converters/inkscape.test.ts
+++ b/tests/converters/inkscape.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/inkscape.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});
diff --git a/tests/converters/libheif.test.ts b/tests/converters/libheif.test.ts
index 267734d..9fb72fc 100644
--- a/tests/converters/libheif.test.ts
+++ b/tests/converters/libheif.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/libheif.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});
diff --git a/tests/converters/libjxl.test.ts b/tests/converters/libjxl.test.ts
index c591570..ad4e5f4 100644
--- a/tests/converters/libjxl.test.ts
+++ b/tests/converters/libjxl.test.ts
@@ -2,12 +2,7 @@ import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
 import { convert } from "../../src/converters/libjxl.ts";
 import { ExecFileFn } from "../../src/converters/types.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
 let command: string = "";
 
@@ -15,21 +10,7 @@ beforeEach(() => {
   command = "";
 });
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
-
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+runCommonTests(convert);
 
 test("convert uses djxl with input filetype being jxl", async () => {
   const originalConsoleLog = console.log;
diff --git a/tests/converters/potrace.test.ts b/tests/converters/potrace.test.ts
index f1852a7..61c3895 100644
--- a/tests/converters/potrace.test.ts
+++ b/tests/converters/potrace.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/potrace.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});
diff --git a/tests/converters/resvg.test.ts b/tests/converters/resvg.test.ts
index cdcb6b9..ce7be18 100644
--- a/tests/converters/resvg.test.ts
+++ b/tests/converters/resvg.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/resvg.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});
diff --git a/tests/converters/vips.test.ts b/tests/converters/vips.test.ts
index 010a7a0..ec6420d 100644
--- a/tests/converters/vips.test.ts
+++ b/tests/converters/vips.test.ts
@@ -2,12 +2,7 @@ import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
 import { ExecFileFn } from "../../src/converters/types.ts";
 import { convert } from "../../src/converters/vips.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
 let calls: string[][] = [];
 
@@ -15,21 +10,7 @@ beforeEach(() => {
   calls = [];
 });
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
-
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+runCommonTests(convert);
 
 test("convert uses action pdfload with filetype being pdf", async () => {
   const originalConsoleLog = console.log;
diff --git a/tests/converters/xelatex.test.ts b/tests/converters/xelatex.test.ts
index 5794b70..f05ea15 100644
--- a/tests/converters/xelatex.test.ts
+++ b/tests/converters/xelatex.test.ts
@@ -1,24 +1,7 @@
 import { test } from "bun:test";
 import { convert } from "../../src/converters/xelatex.ts";
-import {
-  runConvertFailTest,
-  runConvertLogsStderror,
-  runConvertLogsStderrorAndStdout,
-  runConvertSuccessTest,
-} from "./helpers/converters.ts";
+import { runCommonTests } from "./helpers/commonTests.ts";
 
-test("convert resolves when execFile succeeds", async () => {
-  await runConvertSuccessTest(convert);
-});
+runCommonTests(convert);
 
-test("convert rejects when execFile fails", async () => {
-  await runConvertFailTest(convert);
-});
-
-test("convert logs stderr when present", async () => {
-  await runConvertLogsStderror(convert);
-});
-
-test("convert logs both stderr and stdout when present", async () => {
-  await runConvertLogsStderrorAndStdout(convert);
-});
+test.skip("dummy - required to trigger test detection", () => {});

From 3dccbfc797c9e7ddce3541232ab00d020d6b4e3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Mon, 11 Aug 2025 14:24:28 +0200
Subject: [PATCH 29/30] test: add tests directory to tsconfig

---
 tsconfig.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tsconfig.json b/tsconfig.json
index 234339b..ffd5668 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -30,5 +30,5 @@
     "esModuleInterop": true
     // "noImplicitReturns": true
   },
-  "include": ["src", "package.json", "reset.d.ts"]
+  "include": ["src", "tests", "package.json", "reset.d.ts"]
 }

From d994c3821940db10893d2b49c6e22b6d0c5c09d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=B6rg=20Krzeslak?= <selanne08@gmx.de>
Date: Mon, 11 Aug 2025 15:09:20 +0200
Subject: [PATCH 30/30] test: fix imports after eslint config changes

---
 src/converters/assimp.ts                | 2 +-
 src/converters/calibre.ts               | 2 +-
 src/converters/dvisvgm.ts               | 2 +-
 src/converters/ffmpeg.ts                | 2 +-
 src/converters/graphicsmagick.ts        | 2 +-
 src/converters/imagemagick.ts           | 2 +-
 src/converters/inkscape.ts              | 2 +-
 src/converters/libheif.ts               | 2 +-
 src/converters/libjxl.ts                | 2 +-
 src/converters/libreoffice.ts           | 2 +-
 src/converters/msgconvert.ts            | 2 +-
 src/converters/pandoc.ts                | 2 +-
 src/converters/potrace.ts               | 2 +-
 src/converters/resvg.ts                 | 2 +-
 src/converters/vips.ts                  | 2 +-
 src/converters/xelatex.ts               | 2 +-
 tests/converters/assimp.test.ts         | 4 ++--
 tests/converters/calibre.test.ts        | 4 ++--
 tests/converters/dvisvgm.test.ts        | 6 +++---
 tests/converters/ffmpeg.test.ts         | 2 +-
 tests/converters/graphicsmagick.test.ts | 4 ++--
 tests/converters/helpers/commonTests.ts | 4 ++--
 tests/converters/helpers/converters.ts  | 2 +-
 tests/converters/imagemagick.test.ts    | 6 +++---
 tests/converters/inkscape.test.ts       | 4 ++--
 tests/converters/libheif.test.ts        | 4 ++--
 tests/converters/libjxl.test.ts         | 6 +++---
 tests/converters/msgconvert.test.ts     | 4 ++--
 tests/converters/potrace.test.ts        | 4 ++--
 tests/converters/resvg.test.ts          | 4 ++--
 tests/converters/vips.test.ts           | 6 +++---
 tests/converters/xelatex.test.ts        | 4 ++--
 32 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/src/converters/assimp.ts b/src/converters/assimp.ts
index 869f28e..69f3258 100644
--- a/src/converters/assimp.ts
+++ b/src/converters/assimp.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/calibre.ts b/src/converters/calibre.ts
index 153de16..1d06695 100644
--- a/src/converters/calibre.ts
+++ b/src/converters/calibre.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/dvisvgm.ts b/src/converters/dvisvgm.ts
index 76ef5c1..a48bc69 100644
--- a/src/converters/dvisvgm.ts
+++ b/src/converters/dvisvgm.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/ffmpeg.ts b/src/converters/ffmpeg.ts
index 8207c61..f7d183f 100644
--- a/src/converters/ffmpeg.ts
+++ b/src/converters/ffmpeg.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 // This could be done dynamically by running `ffmpeg -formats` and parsing the output
 export const properties = {
diff --git a/src/converters/graphicsmagick.ts b/src/converters/graphicsmagick.ts
index 5551341..4af168e 100644
--- a/src/converters/graphicsmagick.ts
+++ b/src/converters/graphicsmagick.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/imagemagick.ts b/src/converters/imagemagick.ts
index eb2eaa7..69eb359 100644
--- a/src/converters/imagemagick.ts
+++ b/src/converters/imagemagick.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 // declare possible conversions
 export const properties = {
diff --git a/src/converters/inkscape.ts b/src/converters/inkscape.ts
index 4497e2f..dce123b 100644
--- a/src/converters/inkscape.ts
+++ b/src/converters/inkscape.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/libheif.ts b/src/converters/libheif.ts
index b88e177..3df1f52 100644
--- a/src/converters/libheif.ts
+++ b/src/converters/libheif.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/libjxl.ts b/src/converters/libjxl.ts
index 6ff825f..336ad51 100644
--- a/src/converters/libjxl.ts
+++ b/src/converters/libjxl.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 // declare possible conversions
 export const properties = {
diff --git a/src/converters/libreoffice.ts b/src/converters/libreoffice.ts
index 73249dc..02f389a 100644
--- a/src/converters/libreoffice.ts
+++ b/src/converters/libreoffice.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/msgconvert.ts b/src/converters/msgconvert.ts
index 0c0b663..612a2ef 100644
--- a/src/converters/msgconvert.ts
+++ b/src/converters/msgconvert.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/pandoc.ts b/src/converters/pandoc.ts
index e5b1db1..c14c98b 100644
--- a/src/converters/pandoc.ts
+++ b/src/converters/pandoc.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/potrace.ts b/src/converters/potrace.ts
index 6027491..b18f202 100644
--- a/src/converters/potrace.ts
+++ b/src/converters/potrace.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/resvg.ts b/src/converters/resvg.ts
index 3155483..fcdc2e4 100644
--- a/src/converters/resvg.ts
+++ b/src/converters/resvg.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/src/converters/vips.ts b/src/converters/vips.ts
index b89db12..310053f 100644
--- a/src/converters/vips.ts
+++ b/src/converters/vips.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 // declare possible conversions
 export const properties = {
diff --git a/src/converters/xelatex.ts b/src/converters/xelatex.ts
index 784acdc..6bd0802 100644
--- a/src/converters/xelatex.ts
+++ b/src/converters/xelatex.ts
@@ -1,5 +1,5 @@
 import { execFile as execFileOriginal } from "node:child_process";
-import { ExecFileFn } from "./types.ts";
+import { ExecFileFn } from "./types";
 
 export const properties = {
   from: {
diff --git a/tests/converters/assimp.test.ts b/tests/converters/assimp.test.ts
index e032093..ea3479b 100644
--- a/tests/converters/assimp.test.ts
+++ b/tests/converters/assimp.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/assimp.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/assimp";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);
 
diff --git a/tests/converters/calibre.test.ts b/tests/converters/calibre.test.ts
index 91c1b23..773017d 100644
--- a/tests/converters/calibre.test.ts
+++ b/tests/converters/calibre.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/calibre.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/calibre";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);
 
diff --git a/tests/converters/dvisvgm.test.ts b/tests/converters/dvisvgm.test.ts
index a638f13..2723801 100644
--- a/tests/converters/dvisvgm.test.ts
+++ b/tests/converters/dvisvgm.test.ts
@@ -1,8 +1,8 @@
 import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
-import { convert } from "../../src/converters/dvisvgm.ts";
-import { ExecFileFn } from "../../src/converters/types.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/dvisvgm";
+import { ExecFileFn } from "../../src/converters/types";
+import { runCommonTests } from "./helpers/commonTests";
 
 let calls: string[][] = [];
 
diff --git a/tests/converters/ffmpeg.test.ts b/tests/converters/ffmpeg.test.ts
index 01d4633..6f0afc6 100644
--- a/tests/converters/ffmpeg.test.ts
+++ b/tests/converters/ffmpeg.test.ts
@@ -1,5 +1,5 @@
 import { beforeEach, expect, test } from "bun:test";
-import { convert } from "../../src/converters/ffmpeg.ts";
+import { convert } from "../../src/converters/ffmpeg";
 
 let calls: string[][] = [];
 
diff --git a/tests/converters/graphicsmagick.test.ts b/tests/converters/graphicsmagick.test.ts
index 625ec0d..81fbfe4 100644
--- a/tests/converters/graphicsmagick.test.ts
+++ b/tests/converters/graphicsmagick.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/graphicsmagick.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/graphicsmagick";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);
 
diff --git a/tests/converters/helpers/commonTests.ts b/tests/converters/helpers/commonTests.ts
index 9b6b4f0..64483b3 100644
--- a/tests/converters/helpers/commonTests.ts
+++ b/tests/converters/helpers/commonTests.ts
@@ -1,11 +1,11 @@
 import { test } from "bun:test";
-import { ConvertFnWithExecFile } from "../../../src/converters/types.ts";
+import { ConvertFnWithExecFile } from "../../../src/converters/types";
 import {
   runConvertFailTest,
   runConvertLogsStderror,
   runConvertLogsStderrorAndStdout,
   runConvertSuccessTest,
-} from "./converters.ts";
+} from "./converters";
 
 export function runCommonTests(convert: ConvertFnWithExecFile) {
   test("convert resolves when execFile succeeds", async () => {
diff --git a/tests/converters/helpers/converters.ts b/tests/converters/helpers/converters.ts
index f941bc9..12942f6 100644
--- a/tests/converters/helpers/converters.ts
+++ b/tests/converters/helpers/converters.ts
@@ -1,6 +1,6 @@
 import type { ExecFileException } from "node:child_process";
 import { expect } from "bun:test";
-import { ConvertFnWithExecFile, ExecFileFn } from "../../../src/converters/types.ts";
+import { ConvertFnWithExecFile, ExecFileFn } from "../../../src/converters/types";
 
 export async function runConvertSuccessTest(convertFn: ConvertFnWithExecFile) {
   const originalConsoleLog = console.log;
diff --git a/tests/converters/imagemagick.test.ts b/tests/converters/imagemagick.test.ts
index 4916177..dd47b7a 100644
--- a/tests/converters/imagemagick.test.ts
+++ b/tests/converters/imagemagick.test.ts
@@ -1,8 +1,8 @@
 import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
-import { convert } from "../../src/converters/imagemagick.ts";
-import { ExecFileFn } from "../../src/converters/types.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/imagemagick";
+import { ExecFileFn } from "../../src/converters/types";
+import { runCommonTests } from "./helpers/commonTests";
 
 let calls: string[][] = [];
 
diff --git a/tests/converters/inkscape.test.ts b/tests/converters/inkscape.test.ts
index ad15a3b..a75ea3b 100644
--- a/tests/converters/inkscape.test.ts
+++ b/tests/converters/inkscape.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/inkscape.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/inkscape";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);
 
diff --git a/tests/converters/libheif.test.ts b/tests/converters/libheif.test.ts
index 9fb72fc..48d8154 100644
--- a/tests/converters/libheif.test.ts
+++ b/tests/converters/libheif.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/libheif.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/libheif";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);
 
diff --git a/tests/converters/libjxl.test.ts b/tests/converters/libjxl.test.ts
index ad4e5f4..7171bdb 100644
--- a/tests/converters/libjxl.test.ts
+++ b/tests/converters/libjxl.test.ts
@@ -1,8 +1,8 @@
 import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
-import { convert } from "../../src/converters/libjxl.ts";
-import { ExecFileFn } from "../../src/converters/types.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/libjxl";
+import { ExecFileFn } from "../../src/converters/types";
+import { runCommonTests } from "./helpers/commonTests";
 
 let command: string = "";
 
diff --git a/tests/converters/msgconvert.test.ts b/tests/converters/msgconvert.test.ts
index ffdf840..7ef0dca 100644
--- a/tests/converters/msgconvert.test.ts
+++ b/tests/converters/msgconvert.test.ts
@@ -1,7 +1,7 @@
 import type { ExecFileException } from "node:child_process";
 import { expect, test } from "bun:test";
-import { convert } from "../../src/converters/msgconvert.ts";
-import { ExecFileFn } from "../../src/converters/types.ts";
+import { convert } from "../../src/converters/msgconvert";
+import { ExecFileFn } from "../../src/converters/types";
 
 test("convert rejects conversion if input filetype is not msg and output type is not eml", async () => {
   const mockExecFile: ExecFileFn = (
diff --git a/tests/converters/potrace.test.ts b/tests/converters/potrace.test.ts
index 61c3895..90dd86b 100644
--- a/tests/converters/potrace.test.ts
+++ b/tests/converters/potrace.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/potrace.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/potrace";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);
 
diff --git a/tests/converters/resvg.test.ts b/tests/converters/resvg.test.ts
index ce7be18..88b3aba 100644
--- a/tests/converters/resvg.test.ts
+++ b/tests/converters/resvg.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/resvg.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/resvg";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);
 
diff --git a/tests/converters/vips.test.ts b/tests/converters/vips.test.ts
index ec6420d..b97be81 100644
--- a/tests/converters/vips.test.ts
+++ b/tests/converters/vips.test.ts
@@ -1,8 +1,8 @@
 import type { ExecFileException } from "node:child_process";
 import { beforeEach, expect, test } from "bun:test";
-import { ExecFileFn } from "../../src/converters/types.ts";
-import { convert } from "../../src/converters/vips.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { ExecFileFn } from "../../src/converters/types";
+import { convert } from "../../src/converters/vips";
+import { runCommonTests } from "./helpers/commonTests";
 
 let calls: string[][] = [];
 
diff --git a/tests/converters/xelatex.test.ts b/tests/converters/xelatex.test.ts
index f05ea15..5e5f0b0 100644
--- a/tests/converters/xelatex.test.ts
+++ b/tests/converters/xelatex.test.ts
@@ -1,6 +1,6 @@
 import { test } from "bun:test";
-import { convert } from "../../src/converters/xelatex.ts";
-import { runCommonTests } from "./helpers/commonTests.ts";
+import { convert } from "../../src/converters/xelatex";
+import { runCommonTests } from "./helpers/commonTests";
 
 runCommonTests(convert);