bits-to-dead-trees 1.5.1 → 2.0.1

package/test/app.test.ts

@@ -0,0 +1,249 @@
+import { chromium } from "playwright-core";
+import { afterEach, beforeEach, describe, expect, it, vi, Mock } from "vitest";
+
+import build, {
+  defaultBrowserContextOptions,
+  defaultGotoOptions,
+} from "../app";
+const app = build();
+
+describe("GET /health", () => {
+  it("provides a simple health check", async () => {
+    const response = await app.inject({
+      method: "GET",
+      url: "/health",
+    });
+
+    expect(response.statusCode).toEqual(200);
+  });
+});
+
+vi.mock("playwright-core", () => {
+  const playwright = {
+    chromium: {
+      launch: vi.fn(),
+    },
+  };
+  return playwright;
+});
+
+describe("POST /pdf", () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  let gotoMethod = vi.fn();
+  let pdf = vi.fn();
+  let newPage = vi.fn();
+  let newContext = vi.fn();
+  let close = vi.fn();
+
+  beforeEach(() => {
+    gotoMethod = vi.fn().mockResolvedValue({
+      ok() {
+        return true;
+      },
+      status() {
+        return 200;
+      },
+    });
+    pdf = vi.fn().mockResolvedValue(Buffer.from("pdf"));
+    newPage = vi.fn().mockResolvedValue({ goto: gotoMethod, pdf });
+    newContext = vi.fn().mockResolvedValue({ newPage });
+
+    (chromium.launch as Mock<any[], any>).mockResolvedValue({
+      newContext,
+      close,
+    });
+  });
+
+  it("sends a buffer of the PDF as response", async () => {
+    const response = await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: { url: "/foobar" },
+    });
+
+    expect(gotoMethod).toHaveBeenCalledTimes(1);
+    expect(gotoMethod).toHaveBeenLastCalledWith("/foobar", defaultGotoOptions);
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.payload).toEqual("pdf");
+  });
+
+  it("allows to overwrite gotoOptions but merges them with the defaults", async () => {
+    await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: { url: "/foobar", gotoOptions: { timeout: 300 } },
+    });
+
+    expect(gotoMethod).toHaveBeenCalledWith("/foobar", {
+      timeout: 300,
+      waitUntil: "networkidle",
+    });
+  });
+
+  it("uses the default browserContextOptions if not passed or empty", async () => {
+    await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: { url: "/foobar", browserContextOptions: {} },
+    });
+
+    expect(newContext).toHaveBeenCalledWith(defaultBrowserContextOptions);
+  });
+
+  it("allows to overwrite browserContextOptions", async () => {
+    await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "/foobar",
+        browserContextOptions: { ignoreHTTPSErrors: false },
+      },
+    });
+
+    expect(newContext).toHaveBeenCalledWith({
+      ignoreHTTPSErrors: false,
+    });
+  });
+
+  it("returns validation errors", async () => {
+    const response = await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "/foobar",
+        gotoOptions: { doesNot: "exist" },
+      },
+    });
+
+    expect(response.statusCode).toEqual(400);
+
+    const parsedResponse = JSON.parse(response.body);
+
+    expect(parsedResponse.error).toBeTruthy();
+    expect(parsedResponse.message).toContain("body/gotoOptions");
+  });
+
+  it("returns error if page could not load", async () => {
+    gotoMethod.mockResolvedValue({
+      ok() {
+        return false;
+      },
+
+      status() {
+        return 404;
+      },
+
+      statusText() {
+        return "Not found";
+      },
+
+      async text() {
+        return "We tried very hard, but could not find the page.";
+      },
+    });
+
+    const response = await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "/foobar",
+      },
+    });
+
+    expect(response.statusCode).toEqual(404);
+    const error = JSON.parse(response.body);
+
+    expect(error).toMatchObject({
+      error: true,
+      status: 404,
+      statusText: "Not found",
+      message: "We tried very hard, but could not find the page.",
+    });
+  });
+
+  it("allows to pass options to the pdf call", async () => {
+    await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "/foobar",
+        pdfOptions: {
+          headerTemplate: "moin",
+        },
+      },
+    });
+
+    expect(pdf).toHaveBeenCalledWith({ headerTemplate: "moin" });
+  });
+
+  it("returns 500 if something broke", async () => {
+    pdf.mockRejectedValue(new Error("OH NO"));
+
+    const response = await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "/foobar",
+      },
+    });
+
+    expect(response.statusCode).toEqual(500);
+    expect(JSON.parse(response.body)).toMatchObject({
+      statusCode: 500,
+      error: "Internal Server Error",
+      message: "OH NO",
+    });
+  });
+
+  it("allows null as empty for options", async () => {
+    await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: { url: "/foobar", gotoOptions: null },
+    });
+
+    expect(gotoMethod).toHaveBeenCalledWith("/foobar", defaultGotoOptions);
+  });
+
+  it("closes the browser", async () => {
+    pdf.mockRejectedValue("OH NO");
+
+    await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "/foobar",
+      },
+    });
+
+    expect(close).toHaveBeenCalled();
+  });
+
+  it("generates the pdf before closing the browser", async () => {
+    let i = 0;
+
+    pdf.mockImplementation(async () => {
+      await new Promise((r) => setTimeout(r, 100));
+
+      return i++;
+    });
+
+    close.mockImplementation(() => {
+      return i++;
+    });
+
+    await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "https://google.com",
+      },
+    });
+
+    expect(pdf.mock.results[0].value).toBeLessThan(close.mock.results[0].value);
+  });
+});

package/test/smoke.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+
+import build from "../app";
+const app = build();
+
+describe("Smoke tests", () => {
+  it("sends the PDF on the success case", async () => {
+    const response = await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: { url: "https://coding-robin.de" },
+    });
+
+    expect(response.payload.startsWith("%PDF")).toBeTruthy();
+  });
+
+  it("returns an error object when the page could not be loaded", async () => {
+    const response = await app.inject({
+      method: "POST",
+      url: "/pdf",
+      payload: {
+        url: "http://httpbin.org/status/404",
+      },
+    });
+
+    expect(response.statusCode).toEqual(404);
+    const error = JSON.parse(response.body);
+
+    expect(error).toMatchObject({
+      error: true,
+      status: 404,
+      statusText: "NOT FOUND",
+      message: "",
+    });
+  });
+});

package/tsconfig.json

@@ -7,6 +7,8 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "module": "ESNext",
 
     "checkJs": true
   }

package/types/schemas.ts

@@ -1,7 +1,10 @@
-import { Page } from "playwright-core";
+import { BrowserContextOptions, Page } from "playwright-core";
 
 export type PdfOptions = Parameters<Page["pdf"]>[0];
+export type GotoOptions = Parameters<Page["goto"]>[1];
 export type PdfRequestBody = {
   url: string;
-  options?: PdfOptions;
+  pdfOptions?: PdfOptions | null;
+  gotoOptions?: GotoOptions | null;
+  browserContextOptions?: BrowserContextOptions | null;
 };

package/index.js

@@ -1,95 +0,0 @@
-// @ts-check
-
-/**
- * @typedef {Parameters<import("playwright-core").Page["pdf"]>[0]} PdfOptions
- */
-
-/**
- * @typedef {Object} PdfRequestBody
- * @property {string} url
- * @property {PdfOptions} options
- */
-
-const { fastify } = require("fastify");
-const playwright = require("playwright-core");
-const PdfRequestBodySchema = require("./pdf_request_body.json");
-
-const SERVER_PORT = process.env["SERVER_PORT"] ?? 8000;
-const SERVER_ADDRESS = process.env["SERVER_ADDRESS"] ?? "localhost";
-
-const server = fastify({
-  logger: {
-    transport:
-      process.env["NODE_ENV"] !== "production"
-        ? {
-            target: "pino-pretty",
-            options: {
-              translateTime: "HH:MM:ss Z",
-              ignore: "pid,hostname",
-            },
-          }
-        : undefined,
-  },
-});
-
-/**
- *
- * @param {string} url
- * @param {PdfOptions} options
- * @returns Buffer
- */
-const createPDF = async (url, options = {}) => {
-  const browser = await playwright.chromium.launch();
-  const context = await browser.newContext({ ignoreHTTPSErrors: true });
-  const page = await context.newPage();
-  await page.goto(url, { timeout: 60000 });
-  await page.waitForLoadState("networkidle");
-
-  const pdf = await page.pdf(options);
-  await browser.close();
-
-  return pdf;
-};
-
-server.post(
-  "/pdf",
-  { schema: { body: PdfRequestBodySchema }, attachValidation: true },
-  /**
-   *
-   * @param {import('fastify').FastifyRequest<{Body: PdfRequestBody}>} request
-   * @param {import('fastify').FastifyReply} response
-   */
-  async (request, response) => {
-    if (request.validationError) {
-      response.code(400);
-
-      return {
-        error: true,
-        message: request.validationError.message,
-      };
-    }
-
-    try {
-      return createPDF(request.body.url, request.body.options);
-    } catch (error) {
-      response.code(500);
-
-      return {
-        error,
-      };
-    }
-  }
-);
-
-server.get("/health", async (_, response) => response.code(200).send());
-
-const startServer = async () => {
-  try {
-    await server.listen({ port: +SERVER_PORT, host: SERVER_ADDRESS });
-  } catch (error) {
-    console.error(error);
-    process.exit(1);
-  }
-};
-
-startServer();