Skip to content

A fast, helpful, and open-source document parser

feat: unit tests (engines, ocr)

Clelia (Astra) Bertelli7fa3ef01c7a8
diff --git a/src/engines/ocr/http-simple.test.ts b/src/engines/ocr/http-simple.test.ts
new file mode 100644
index 0000000..77ebb82
--- /dev/null
+++ b/src/engines/ocr/http-simple.test.ts
@@ -0,0 +1,117 @@
+import { vi, describe, it, expect } from "vitest";
+import { PassThrough } from "stream";
+
+const mockStream = new PassThrough();
+const mockOcrItems = [
+ {
+ text: "Hello World",
+ bbox: [0, 0, 100, 20],
+ confidence: 0.99,
+ },
+ {
+ text: "Some text",
+ bbox: [0, 25, 100, 45],
+ confidence: 0.95,
+ },
+];
+
+vi.mock("fs", async () => {
+ const actual = await vi.importActual<typeof import("fs")>("fs");
+ return {
+ ...actual,
+ default: {
+ createReadStream: vi.fn(() => {
+ return mockStream;
+ }),
+ },
+ };
+});
+
+vi.mock("axios", async () => {
+ const actual = await vi.importActual<typeof import("axios")>("axios");
+ return {
+ default: {
+ ...actual,
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ post: vi.fn(async (url: string, _formData?: any | undefined, _config?: any | undefined) => {
+ if (url == "http://localhost:9999") {
+ throw new actual.AxiosError("Endpoint not found", "404 Not Found");
+ } else if (url == "http://localhost:10000") {
+ throw new Error("Unrecheable server");
+ } else if (url == "http://localhost:9998") {
+ // not an array
+ return {
+ data: { results: mockOcrItems[0] },
+ };
+ }
+ return {
+ data: { results: mockOcrItems },
+ };
+ }),
+ },
+ };
+});
+
+import { HttpOcrEngine } from "./http-simple";
+
+describe("test OCR simple HTTP server (single image)", () => {
+ it("test server success", async () => {
+ const server = new HttpOcrEngine("http://localhost:8000");
+ expect(server.name).toBe("http-ocr");
+ const result = await server.recognize("cat.png", { language: "en" });
+ expect(result).toStrictEqual(mockOcrItems);
+ });
+
+ it("test server axios error", async () => {
+ const server = new HttpOcrEngine("http://localhost:9999");
+ const result = await server.recognize("cat.png", { language: "en" });
+ expect(result.length).toBe(0);
+ });
+
+ it("test server generic error", async () => {
+ const server = new HttpOcrEngine("http://localhost:10000");
+ const result = await server.recognize("cat.png", { language: "en" });
+ expect(result.length).toBe(0);
+ });
+
+ it("test server malformed response", async () => {
+ const server = new HttpOcrEngine("http://localhost:9998");
+ const result = await server.recognize("cat.png", { language: "en" });
+ expect(result.length).toBe(0);
+ });
+});
+
+describe("test OCR simple HTTP server (batch)", () => {
+ it("test server success", async () => {
+ const server = new HttpOcrEngine("http://localhost:8000");
+ const result = await server.recognizeBatch(["cat.png", "dog.png"], { language: "en" });
+ expect(result).toStrictEqual([mockOcrItems, mockOcrItems]);
+ });
+
+ it("test server axios error", async () => {
+ const server = new HttpOcrEngine("http://localhost:9999");
+ const result = await server.recognizeBatch(["cat.png", "dog.png"], { language: "en" });
+ expect(result.length).toBe(2);
+ for (const r of result) {
+ expect(r.length).toBe(0);
+ }
+ });
+
+ it("test server generic error", async () => {
+ const server = new HttpOcrEngine("http://localhost:10000");
+ const result = await server.recognizeBatch(["cat.png", "dog.png"], { language: "en" });
+ expect(result.length).toBe(2);
+ for (const r of result) {
+ expect(r.length).toBe(0);
+ }
+ });
+
+ it("test server malformed response", async () => {
+ const server = new HttpOcrEngine("http://localhost:9998");
+ const result = await server.recognizeBatch(["cat.png", "dog.png"], { language: "en" });
+ expect(result.length).toBe(2);
+ for (const r of result) {
+ expect(r.length).toBe(0);
+ }
+ });
+});
diff --git a/src/engines/ocr/tesseract.test.ts b/src/engines/ocr/tesseract.test.ts
new file mode 100644
index 0000000..aca71ee
--- /dev/null
+++ b/src/engines/ocr/tesseract.test.ts
@@ -0,0 +1,99 @@
+import { vi, describe, it, expect } from "vitest";
+
+const mockTesseractResult = {
+ data: {
+ text: "Hello World",
+ words: [
+ {
+ text: "Hello",
+ confidence: 95,
+ bbox: { x0: 0, y0: 0, x1: 50, y1: 20 },
+ },
+ {
+ text: "World",
+ confidence: 92,
+ bbox: { x0: 60, y0: 0, x1: 120, y1: 20 },
+ },
+ ],
+ lines: [
+ {
+ text: "Hello World",
+ confidence: 93,
+ bbox: { x0: 0, y0: 0, x1: 120, y1: 20 },
+ words: [], // ref to words above if needed
+ },
+ ],
+ confidence: 93,
+ },
+};
+
+const {
+ data: { words: mockWords },
+} = mockTesseractResult;
+
+const mockResults = mockWords.map((word) => ({
+ text: word.text,
+ bbox: [word.bbox.x0, word.bbox.y0, word.bbox.x1, word.bbox.y1] as [
+ number,
+ number,
+ number,
+ number,
+ ],
+ confidence: word.confidence / 100, // Tesseract returns 0-100, we want 0-1
+}));
+
+const mockTesseractWorker = {
+ terminate: vi.fn(async () => {}),
+ recognize: vi.fn(async () => {
+ return mockTesseractResult;
+ }),
+};
+
+vi.mock("tesseract.js", async () => {
+ const actual = await vi.importActual<typeof import("tesseract.js")>("tesseract.js");
+ return {
+ ...actual,
+ createWorker: vi.fn(async (language: string, _num: number) => {
+ if (language == "it" || language == "ita") {
+ return;
+ }
+ return mockTesseractWorker;
+ }),
+ };
+});
+
+import { TesseractEngine } from "./tesseract";
+
+describe("test Tesseract OCR (single image)", () => {
+ it("test engine success", async () => {
+ const engine = new TesseractEngine();
+ expect(engine.name).toBe("tesseract");
+ const result = await engine.recognize("cat.png", { language: "en" });
+ expect(result).toStrictEqual(mockResults);
+ });
+
+ it("test engine failure (failed to initialize)", async () => {
+ const engine = new TesseractEngine();
+ expect(engine.name).toBe("tesseract");
+ expect(engine.recognize("cat.png", { language: "it" })).rejects.toThrow(
+ "Tesseract worker not initialized"
+ );
+ });
+});
+
+describe("test OCR simple HTTP server (batch)", () => {
+ it("test engine success", async () => {
+ const engine = new TesseractEngine();
+ expect(engine.name).toBe("tesseract");
+ const result = await engine.recognizeBatch(["cat.png", "dog.png"], { language: "en" });
+ expect(result).toStrictEqual([mockResults, mockResults]);
+ });
+
+ it("test engine failure (failed to initialize)", async () => {
+ const engine = new TesseractEngine();
+ expect(engine.name).toBe("tesseract");
+ expect(engine.recognizeBatch(["cat.png", "dog.png"], { language: "it" })).rejects.toThrow(
+ "Tesseract worker not initialized"
+ );
+ });
+});