chromiumly 2.0.0 → 2.0.3

package/README.md

@@ -1,7 +1,29 @@
 # Chromiumly
 
+![build](https://github.com/cherfia/chromiumly/actions/workflows/build.yml/badge.svg)
+[![coverage](https://img.shields.io/codecov/c/gh/cherfia/chromiumly?style=flat-square)](https://codecov.io/gh/cherfia/chromiumly)
+[![vulnerabilities](https://snyk.io/test/github/cherfia/chromiumly/badge.svg?targetFile=package.json&color=brightgreen&style=flat-square)](https://snyk.io/test/github/cherfia/chromiumly?targetFile=package.json)
+[![maintainability](https://img.shields.io/codeclimate/maintainability/cherfia/chromiumly?color=yellow&style=flat-square)](https://codeclimate.com/github/cherfia/chromiumly/maintainability)
+[![npm](https://img.shields.io/npm/v/chromiumly?color=brightgreen&style=flat-square)](https://npmjs.org/package/chromiumly)
+[![downloads](https://img.shields.io/npm/dt/chromiumly.svg?color=brightgreen&style=flat-square)](https://npm-stat.com/charts.html?package=chromiumly)
+![licence](https://img.shields.io/github/license/cherfia/chromiumly?style=flat-square)
+
 A lightweight Typescrpit library which interacts with [Gotenberg](https://gotenberg.dev/)'s different modules to convert a variety of document formats to PDF files.
 
+## Install
+
+Using npm:
+
+```bash
+npm install chromiumly
+```
+
+Using yarn:
+
+```bash
+yarn add chromiumly
+```
+
 ## Prerequisites
 
 Before attempting to use Chromiumly, be sure you install [Docker](https://www.docker.com/) if you have not already done so.

package/dist/pdf-engines/utils/engine.utils.js

@@ -11,7 +11,13 @@ class PDFEngineUtils {
                 try {
                     yield fs_1.promises.access(file, fs_1.constants.R_OK);
                     const filename = path_1.default.basename(file.toString());
-                    data.append(filename, (0, fs_1.createReadStream)(file));
+                    const extension = path_1.default.extname(filename);
+                    if (extension === ".pdf") {
+                        data.append(filename, (0, fs_1.createReadStream)(file));
+                    }
+                    else {
+                        throw new Error(`${extension} is not supported`);
+                    }
                 }
                 catch (error) {
                     throw error;

package/dist/pdf-engines/utils/engine.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"engine.utils.js","sourceRoot":"","sources":["../../../src/pdf-engines/utils/engine.utils.ts"],"names":[],"mappings":";;;;AAAA,2BAAqE;AACrE,wDAAwB;AAIxB,MAAa,cAAc;IAClB,MAAM,CAAO,WAAW,CAAC,KAAiB,EAAE,IAAc;;YAC/D,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;gBACxB,IAAI;oBACF,MAAM,aAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,cAAS,CAAC,IAAI,CAAC,CAAC;oBAC5C,MAAM,QAAQ,GAAG,cAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAChD,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAA,qBAAgB,EAAC,IAAI,CAAC,CAAC,CAAC;iBAC/C;gBAAC,OAAO,KAAK,EAAE;oBACd,MAAM,KAAK,CAAC;iBACb;aACF;QACH,CAAC;KAAA;CACF;AAZD,wCAYC"}
+{"version":3,"file":"engine.utils.js","sourceRoot":"","sources":["../../../src/pdf-engines/utils/engine.utils.ts"],"names":[],"mappings":";;;;AAAA,2BAAqE;AACrE,wDAAwB;AAIxB,MAAa,cAAc;IAClB,MAAM,CAAO,WAAW,CAAC,KAAiB,EAAE,IAAc;;YAC/D,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;gBACxB,IAAI;oBACF,MAAM,aAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,cAAS,CAAC,IAAI,CAAC,CAAC;oBAC5C,MAAM,QAAQ,GAAG,cAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAChD,MAAM,SAAS,GAAG,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;oBACzC,IAAI,SAAS,KAAK,MAAM,EAAE;wBACxB,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAA,qBAAgB,EAAC,IAAI,CAAC,CAAC,CAAC;qBAC/C;yBAAM;wBACL,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,mBAAmB,CAAC,CAAC;qBAClD;iBACF;gBAAC,OAAO,KAAK,EAAE;oBACd,MAAM,KAAK,CAAC;iBACb;aACF;QACH,CAAC;KAAA;CACF;AAjBD,wCAiBC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chromiumly",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "description": "A lightweight Typescrpit library which interacts with Gotenberg's different modules to convert a variety of document formats to PDF files.",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -20,6 +20,7 @@
   "keywords": [
     "gotenberg",
     "chromium",
+    "LibreOffice",
     "html",
     "markdown",
     "pdf"
@@ -27,19 +28,25 @@
   "scripts": {
     "clean": "rm -rf dist build",
     "lint": "eslint src/ --ext .js,.ts",
-    "build": "yarn clean && tsc -p tsconfig.json"
+    "build": "yarn clean && tsc -p tsconfig.json",
+    "test": "jest --runInBand --ci --coverage --reporters=default --reporters=jest-junit"
   },
   "devDependencies": {
+    "@babel/preset-typescript": "^7.16.7",
     "@types/config": "^0.0.41",
     "@types/dotenv": "^8.2.0",
     "@types/form-data": "^2.5.0",
+    "@types/jest": "^27.4.1",
     "@types/node": "^17.0.22",
     "@types/node-fetch": "2",
     "@typescript-eslint/eslint-plugin": "^5.16.0",
     "@typescript-eslint/parser": "^5.16.0",
     "eslint": "^8.11.0",
+    "jest": "^27.5.1",
+    "jest-junit": "^13.0.0",
+    "ts-jest": "^27.1.4",
     "ts-node": "^10.7.0",
-    "typescript": "^4.6.2"
+    "typescript": "4.6.3"
   },
   "dependencies": {
     "config": "^3.3.7",

package/src/chromium/converters/tests/html.converter.test.ts

@@ -0,0 +1,95 @@
+import { promises, createReadStream } from "fs";
+
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+import { PdfFormat } from "../../../common";
+import { HtmlConverter } from "../html.converter";
+
+const { Response } = jest.requireActual("node-fetch");
+jest.mock("node-fetch", () => jest.fn());
+
+describe("HtmlConverter", () => {
+  const mockPromisesAccess = jest.spyOn(promises, "access");
+  const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+  const converter = new HtmlConverter();
+  beforeEach(() => {
+    (createReadStream as jest.Mock) = jest
+      .fn()
+      .mockImplementation((file) => file);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("endpoint", () => {
+    it("should route to Chromium HTML route", () => {
+      expect(converter.endpoint).toEqual(
+        "http://localhost:3000/forms/chromium/convert/html"
+      );
+    });
+  });
+
+  describe("convert", () => {
+    describe("when file exists", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await converter.convert({ html: "path/to/index.html" });
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when pdf format parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await converter.convert({
+          html: "path/to/index.html",
+          pdfFormat: PdfFormat.A_1a,
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(2);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when page properties parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await converter.convert({
+          html: "path/to/index.html",
+          properties: { size: { width: 8.3, height: 11.7 } },
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(3);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when file does not exist", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "ENOENT: no such file or directory, access 'path/to/index.html'";
+        mockPromisesAccess.mockRejectedValue(new Error(errorMessage));
+        await expect(() =>
+          converter.convert({ html: "path/to/index.html" })
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+
+    describe("when fetch request fails", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockRejectedValue(new Error(errorMessage));
+        await expect(() =>
+          converter.convert({ html: "path/to/index.html" })
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+  });
+});

package/src/chromium/converters/tests/markdown.converter.test.ts

@@ -0,0 +1,105 @@
+import { createReadStream, promises } from "fs";
+
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+import { PdfFormat } from "../../../common";
+import { MarkdownConverter } from "../markdown.converter";
+
+const { Response } = jest.requireActual("node-fetch");
+jest.mock("node-fetch", () => jest.fn());
+
+describe("MarkdownConverter", () => {
+  const mockPromisesAccess = jest.spyOn(promises, "access");
+  const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+  const converter = new MarkdownConverter();
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("endpoint", () => {
+    it("should route to Chromium Markdown route", () => {
+      expect(converter.endpoint).toEqual(
+        "http://localhost:3000/forms/chromium/convert/markdown"
+      );
+    });
+  });
+
+  describe("convert", () => {
+    beforeEach(() => {
+      (createReadStream as jest.Mock) = jest.fn().mockImplementation(() => {});
+    });
+
+    describe("when file exists", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await converter.convert({
+          html: "path/to/index.html",
+          markdown: "path/to/file.md",
+        });
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when pdf format parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await converter.convert({
+          html: "path/to/index.html",
+          markdown: "path/to/file.md",
+          pdfFormat: PdfFormat.A_2b,
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(3);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when page properties parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await converter.convert({
+          html: "path/to/index.html",
+          markdown: "path/to/file.md",
+          properties: { size: { width: 8.3, height: 11.7 } },
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(4);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when file does not exist", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "ENOENT: no such file or directory, access 'path/to/index.html'";
+        mockPromisesAccess.mockRejectedValue(new Error(errorMessage));
+
+        await expect(() =>
+          converter.convert({
+            html: "path/to/index.html",
+            markdown: "path/to/file.md",
+          })
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+
+    describe("when fetch request fails", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockRejectedValue(new Error(errorMessage));
+        await expect(() =>
+          converter.convert({
+            html: "path/to/index.html",
+            markdown: "path/to/file.md",
+          })
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+  });
+});

package/src/chromium/converters/tests/url.converter.test.ts

@@ -0,0 +1,82 @@
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+import { PdfFormat } from "../../../common";
+import { UrlConverter } from "../url.converter";
+
+const { Response } = jest.requireActual("node-fetch");
+jest.mock("node-fetch", () => jest.fn());
+
+describe("HtmlConverter", () => {
+  const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+  const converter = new UrlConverter();
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("endpoint", () => {
+    it("should route to Chromium HTML route", () => {
+      expect(converter.endpoint).toEqual(
+        "http://localhost:3000/forms/chromium/convert/url"
+      );
+    });
+  });
+
+  describe("convert", () => {
+    describe("when URL is valid", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const buffer = await converter.convert({
+          url: "http://www.example.com/",
+        });
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when pdf format parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const buffer = await converter.convert({
+          url: "http://www.example.com/",
+          pdfFormat: PdfFormat.A_3b,
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(2);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when page properties parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const buffer = await converter.convert({
+          url: "http://www.example.com/",
+          properties: { size: { width: 8.3, height: 11.7 } },
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(3);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when URL is invalid", () => {
+      it("should throw an error", async () => {
+        await expect(() =>
+          converter.convert({ url: "invalid url" })
+        ).rejects.toThrow("Invalid URL: invalid url");
+      });
+    });
+
+    describe("when fetch request fails", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+        mockFetch.mockRejectedValueOnce(new Error(errorMessage));
+        await expect(() =>
+          converter.convert({ url: "http://www.example.com/" })
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+  });
+});

package/src/chromium/utils/tests/converter.utils.test.ts

@@ -0,0 +1,101 @@
+import FormData from "form-data";
+import { ConverterUtils } from "../converter.utils";
+
+describe("ConverterUtils", () => {
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+  const data = new FormData();
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("injectPageProperties", () => {
+    describe("Page size", () => {
+      describe("when page size is valid", () => {
+        it("should append page size to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            size: { width: 8.3, height: 11.7 },
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(2);
+          expect(data.append).toHaveBeenCalledWith("paperWidth", 8.3);
+          expect(data.append).toHaveBeenNthCalledWith(2, "paperHeight", 11.7);
+        });
+      });
+    });
+
+    describe("Page margins", () => {
+      describe("when page margins are valid", () => {
+        it("should append page margins to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            margins: { top: 0.5, bottom: 0.5, left: 1, right: 1 },
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(4);
+          expect(data.append).toHaveBeenCalledWith("marginTop", 0.5);
+          expect(data.append).toHaveBeenNthCalledWith(2, "marginBottom", 0.5);
+          expect(data.append).toHaveBeenNthCalledWith(3, "marginLeft", 1);
+          expect(data.append).toHaveBeenNthCalledWith(4, "marginRight", 1);
+        });
+      });
+    });
+
+    describe("Page css size", () => {
+      describe("when preferCssPageSize parameter is set", () => {
+        it("should append preferCssPageSize to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            preferCssPageSize: true,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("preferCssPageSize", "true");
+        });
+      });
+    });
+
+    describe("Page background", () => {
+      describe("when printBackground parameter is set", () => {
+        it("should append printBackground to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            printBackground: true,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("printBackground", "true");
+        });
+      });
+    });
+
+    describe("Page landscape", () => {
+      describe("when landscape parameter is set", () => {
+        it("should append landscape to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            landscape: true,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("landscape", "true");
+        });
+      });
+    });
+
+    describe("Page scale", () => {
+      describe("when page scale is valid", () => {
+        it("should append scale to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            scale: 1.5,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("scale", 1.5);
+        });
+      });
+    });
+
+    describe("Page ranges", () => {
+      describe("when nativePageRanges is valid", () => {
+        it("should append nativePageRanges to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            nativePageRanges: { from: 1, to: 6 },
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("nativePageRanges", "1-6");
+        });
+      });
+    });
+  });
+});

package/src/common/tests/gotenberg.utils.test.ts

@@ -0,0 +1,71 @@
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+import { GotenbergUtils } from "./../gotenberg.utils";
+
+const { Response, FetchError } = jest.requireActual("node-fetch");
+
+jest.mock("node-fetch", () => jest.fn());
+
+describe("GotenbergUtils", () => {
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("assert", () => {
+    const errorMessage = "error message";
+    describe("when condition is true", () => {
+      it("should pass", () => {
+        expect(() => GotenbergUtils.assert(true, errorMessage)).not.toThrow();
+      });
+    });
+    describe("when condition is false", () => {
+      it("should return error message", () => {
+        expect(() => GotenbergUtils.assert(false, errorMessage)).toThrow(
+          errorMessage
+        );
+      });
+    });
+  });
+
+  describe("fetch", () => {
+    const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+    const data = new FormData();
+    const endpoint = "http://localhost:3000/forms/chromium/convert/html";
+
+    describe("when fetch request succeeds", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const response = await GotenbergUtils.fetch(endpoint, data);
+        await expect(response).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when fetch request fails", () => {
+      describe("when there is a known error", () => {
+        it("should throw an error", async () => {
+          const errorMessage =
+            "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+          mockFetch.mockRejectedValueOnce(new FetchError(errorMessage));
+          await expect(() =>
+            GotenbergUtils.fetch(endpoint, data)
+          ).rejects.toThrow(errorMessage);
+        });
+      });
+
+      describe("when there is an unknown error", () => {
+        it("should throw an error", async () => {
+          mockFetch.mockResolvedValueOnce(
+            new Response(
+              {},
+              { status: 500, statusText: "Internal server error" }
+            )
+          );
+          await expect(() =>
+            GotenbergUtils.fetch(endpoint, data)
+          ).rejects.toThrow("500 Internal server error");
+        });
+      });
+    });
+  });
+});

package/src/libre-office/utils/test/libre-office.utils.test.ts

@@ -0,0 +1,85 @@
+import { LibreOfficeUtils } from "../libre-office.utils";
+import { promises, createReadStream } from "fs";
+
+import FormData from "form-data";
+
+describe("LibreOfficeUtils", () => {
+  const mockPromisesAccess = jest.spyOn(promises, "access");
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+  const data = new FormData();
+
+  beforeEach(() => {
+    (createReadStream as jest.Mock) = jest
+      .fn()
+      .mockImplementation((file) => file);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("injectFiles", () => {
+    describe("when files exist", () => {
+      it("should append each file to data", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        await LibreOfficeUtils.injectFiles(
+          ["path/to/file.docx", "path/to/file.bib"],
+          data
+        );
+        expect(mockFormDataAppend).toBeCalledTimes(2);
+      });
+    });
+
+    describe("when one of the files has unsupported format", () => {
+      it("should throw an error", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        await expect(() =>
+          LibreOfficeUtils.injectFiles(
+            ["path/to/file.rar", "path/to/file.pdf"],
+            data
+          )
+        ).rejects.toThrow(".rar is not supported");
+      });
+    });
+
+    describe("when one of the files does not exist", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "ENOENT: no such file or directory, access 'path/to/index.html'";
+        mockPromisesAccess.mockRejectedValue(new Error(errorMessage));
+        await expect(() =>
+          LibreOfficeUtils.injectFiles(
+            ["path/to/file.pdf", "path/to/another-file.pdf"],
+            data
+          )
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+  });
+
+  describe("injectPageProperties", () => {
+    describe("Page landscape", () => {
+      describe("when landscape parameter is set", () => {
+        it("should append landscape to data", () => {
+          LibreOfficeUtils.injectPageProperties(data, {
+            landscape: true,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("landscape", "true");
+        });
+      });
+    });
+
+    describe("Page ranges", () => {
+      describe("when nativePageRanges is valid", () => {
+        it("should append nativePageRanges to data", () => {
+          LibreOfficeUtils.injectPageProperties(data, {
+            nativePageRanges: { from: 1, to: 6 },
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("nativePageRanges", "1-6");
+        });
+      });
+    });
+  });
+});

package/src/pdf-engines/tests/pdf.engine.test.ts

@@ -0,0 +1,84 @@
+import path from "path";
+
+import { PDFEngine } from "./../pdf.engine";
+import { PdfFormat } from "../../common";
+
+import { promises, createReadStream } from "fs";
+
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+const { Response } = jest.requireActual("node-fetch");
+jest.mock("node-fetch", () => jest.fn());
+
+describe("PDFEngine", () => {
+  const mockProcessCwd = jest.spyOn(process, "cwd");
+  const mockPromisesAccess = jest.spyOn(promises, "access");
+  const mockPromisesMkDir = jest.spyOn(promises, "mkdir");
+  const mockPromisesWriteFile = jest.spyOn(promises, "writeFile");
+  const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+  beforeEach(() => {
+    (createReadStream as jest.Mock) = jest
+      .fn()
+      .mockImplementation((file) => file);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("convert", () => {
+    describe("when no properties are passed", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await PDFEngine.convert({
+          files: ["path/to/file.docx", "path/to/file.bib"],
+        });
+        expect(buffer).toEqual(Buffer.from("content"));
+        expect(mockFormDataAppend).toBeCalledTimes(2);
+      });
+    });
+
+    describe("when properties are passed", () => {
+      it("should return a buffer", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        mockFetch.mockResolvedValue(new Response("content"));
+        const buffer = await PDFEngine.convert({
+          files: ["path/to/file.docx", "path/to/file.bib"],
+          properties: { landscape: true },
+          pdfFormat: PdfFormat.A_1a,
+          merge: true,
+        });
+        expect(buffer).toEqual(Buffer.from("content"));
+        expect(mockFormDataAppend).toBeCalledTimes(5);
+      });
+    });
+  });
+
+  describe("merge", () => {
+    it("should return a buffer", async () => {
+      mockPromisesAccess.mockResolvedValue();
+      mockFetch.mockResolvedValue(new Response("content"));
+      const buffer = await PDFEngine.merge({
+        files: ["path/to/file.pdf", "path/to/another-file.pdf"],
+      });
+      expect(buffer).toEqual(Buffer.from("content"));
+      expect(mockFormDataAppend).toBeCalledTimes(2);
+    });
+  });
+
+  describe("generate", () => {
+    it("should generate a PDF file", async () => {
+      mockProcessCwd.mockReturnValue("path/to/");
+      mockPromisesMkDir.mockResolvedValue("__generated__");
+      await PDFEngine.generate("file.pdf", Buffer.from("content"));
+      expect(mockPromisesWriteFile).toBeCalledWith(
+        path.resolve("path/to/__generated__/file.pdf"),
+        Buffer.from("content")
+      );
+    });
+  });
+});

package/src/pdf-engines/utils/engine.utils.ts

@@ -9,7 +9,12 @@ export class PDFEngineUtils {
       try {
         await promises.access(file, constants.R_OK);
         const filename = path.basename(file.toString());
-        data.append(filename, createReadStream(file));
+        const extension = path.extname(filename);
+        if (extension === ".pdf") {
+          data.append(filename, createReadStream(file));
+        } else {
+          throw new Error(`${extension} is not supported`);
+        }
       } catch (error) {
         throw error;
       }

package/src/pdf-engines/utils/tests/engine.utils.test.ts

@@ -0,0 +1,59 @@
+import { PDFEngineUtils } from "./../engine.utils";
+import { promises, createReadStream } from "fs";
+
+import FormData from "form-data";
+
+describe("PDFEngineUtils", () => {
+  const mockPromisesAccess = jest.spyOn(promises, "access");
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+  const data = new FormData();
+
+  beforeEach(() => {
+    (createReadStream as jest.Mock) = jest
+      .fn()
+      .mockImplementation((file) => file);
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("injectFiles", () => {
+    describe("when files exist", () => {
+      it("should append each file to data", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        await PDFEngineUtils.injectFiles(
+          ["path/to/file.pdf", "path/to/another-file.pdf"],
+          data
+        );
+        expect(mockFormDataAppend).toBeCalledTimes(2);
+      });
+    });
+
+    describe("when one of the files is not PDF", () => {
+      it("should throw an error", async () => {
+        mockPromisesAccess.mockResolvedValue();
+        await expect(() =>
+          PDFEngineUtils.injectFiles(
+            ["path/to/file.docx", "path/to/file.pdf"],
+            data
+          )
+        ).rejects.toThrow(".docx is not supported");
+      });
+    });
+
+    describe("when one of the files does not exist", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "ENOENT: no such file or directory, access 'path/to/index.html'";
+        mockPromisesAccess.mockRejectedValue(new Error(errorMessage));
+        await expect(() =>
+          PDFEngineUtils.injectFiles(
+            ["path/to/file.pdf", "path/to/another-file.pdf"],
+            data
+          )
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+  });
+});