chromiumly 2.4.0 → 2.5.1

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

@@ -1,181 +1,162 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { createReadStream, promises } from "fs";
+import {createReadStream, promises} from "fs";
 
 import FormData from "form-data";
 import fetch from "node-fetch";
 
-import { PdfFormat } from "../../../common";
-import { MarkdownConverter } from "../markdown.converter";
+import {PdfFormat} from "../../../common";
+import {MarkdownConverter} from "../markdown.converter";
 
-const { Response } = jest.requireActual("node-fetch");
+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((file) => file);
-    });
+    const converter = new MarkdownConverter();
 
-    describe("when files exist", () => {
-      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",
+    describe("endpoint", () => {
+        it("should route to Chromium Markdown route", () => {
+            expect(converter.endpoint).toEqual(
+                "http://localhost:3000/forms/chromium/convert/markdown"
+            );
         });
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
     });
 
-    describe("when buffers passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: Buffer.from("html"),
-          markdown: Buffer.from("markdown"),
+    describe("convert", () => {
+        const mockPromisesAccess = jest.spyOn(promises, "access");
+        const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+        const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+        beforeEach(() => {
+            (createReadStream as jest.Mock) = jest.fn()
         });
-        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,
+        afterEach(() => {
+            jest.resetAllMocks();
+        });
+        
+        describe("when html and markdown parameters are passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    markdown: Buffer.from("markdown"),
+                });
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(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 } },
+
+        describe("when pdf format parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    markdown: Buffer.from("markdown"),
+                    pdfFormat: PdfFormat.A_2b,
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(4);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when header 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",
-          header: "path/to/header.html",
+        describe("when page properties parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    markdown: Buffer.from("markdown"),
+                    properties: {size: {width: 8.3, height: 11.7}},
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(4);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when footer 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",
-          footer: "path/to/footer.html",
+        describe("when header parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    markdown: Buffer.from("markdown"),
+                    header: Buffer.from("header"),
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when emulatedMediaType 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",
-          emulatedMediaType: "screen",
+        describe("when footer parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    markdown: Buffer.from("markdown"),
+                    footer: Buffer.from("footer"),
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
 
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
+        describe("when emulatedMediaType parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    markdown: Buffer.from("markdown"),
+                    emulatedMediaType: "screen",
+                });
+
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
+        });
 
-    describe("when all parameters are 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",
-          header: "path/to/header.html",
-          footer: "path/to/footer.html",
-          pdfFormat: PdfFormat.A_1a,
-          emulatedMediaType: "screen",
-          properties: { size: { width: 8.3, height: 11.7 } },
+        describe("when all parameters are passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    markdown: Buffer.from("markdown"),
+                    header: Buffer.from("header"),
+                    footer: Buffer.from("footer"),
+                    pdfFormat: PdfFormat.A_1a,
+                    emulatedMediaType: "screen",
+                    properties: {size: {width: 8.3, height: 11.7}},
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(8);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(8);
-        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 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);
-      });
+        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

@@ -1,149 +1,140 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { createReadStream, promises } from "fs";
+import {createReadStream} from "fs";
 import FormData from "form-data";
 import fetch from "node-fetch";
 
-import { PdfFormat } from "../../../common";
-import { UrlConverter } from "../url.converter";
+import {PdfFormat} from "../../../common";
+import {UrlConverter} from "../url.converter";
 
-const { Response } = jest.requireActual("node-fetch");
+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 mockPromisesAccess = jest.spyOn(promises, "access");
-
-  const converter = new UrlConverter();
-
-  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/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/",
+    const converter = new UrlConverter();
+
+    describe("endpoint", () => {
+        it("should route to Chromium HTML route", () => {
+            expect(converter.endpoint).toEqual(
+                "http://localhost:3000/forms/chromium/convert/url"
+            );
         });
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
     });
 
-    describe("when header parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockFetch.mockResolvedValueOnce(new Response("content"));
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          url: "http://www.example.com/",
-          header: "path/to/header.html",
+    describe("convert", () => {
+        const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+        const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+        beforeEach(() => {
+            (createReadStream as jest.Mock) = jest.fn()
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when footer parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockFetch.mockResolvedValueOnce(new Response("content"));
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          url: "http://www.example.com/",
-          footer: "path/to/footer.html",
+        afterEach(() => {
+            jest.resetAllMocks();
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-        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,
+        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"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(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 } },
+        describe("when header parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValueOnce(new Response("content"));
+                const buffer = await converter.convert({
+                    url: "http://www.example.com/",
+                    header: Buffer.from("header"),
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when emulatedMediaType parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          url: "http://www.example.com/",
-          emulatedMediaType: "screen",
+        describe("when footer parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValueOnce(new Response("content"));
+                const buffer = await converter.convert({
+                    url: "http://www.example.com/",
+                    footer: Buffer.from("footer"),
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when all parameters are passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          url: "http://www.example.com/",
-          header: "path/to/header.html",
-          footer: "path/to/footer.html",
-          pdfFormat: PdfFormat.A_1a,
-          emulatedMediaType: "screen",
-          properties: { size: { width: 8.3, height: 11.7 } },
+        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).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(7);
-        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");
-      });
-    });
+        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).toHaveBeenCalledTimes(3);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
+        });
 
-    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);
-      });
+        describe("when emulatedMediaType parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    url: "http://www.example.com/",
+                    emulatedMediaType: "screen",
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
+        });
+
+        describe("when all parameters are passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    url: "http://www.example.com/",
+                    header: Buffer.from("header"),
+                    footer: Buffer.from("footer"),
+                    pdfFormat: PdfFormat.A_1a,
+                    emulatedMediaType: "screen",
+                    properties: {size: {width: 8.3, height: 11.7}},
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(7);
+                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");
+            });
+        });
+
+        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);
+            });
+        });
     });
-  });
 });