@xenterprises/fastify-xpdf 1.0.0

package/test/xPDF.test.js

@@ -0,0 +1,903 @@
+// test/xPDF.test.js
+import { test } from "node:test";
+import assert from "node:assert";
+import Fastify from "fastify";
+import xPDF from "../src/xPDF.js";
+import { PDFDocument } from "pdf-lib";
+
+// Helper to create a simple PDF buffer for testing
+async function createSimplePDF() {
+  const pdfDoc = await PDFDocument.create();
+  const page = pdfDoc.addPage();
+  page.drawText("Test PDF");
+  const pdfBytes = await pdfDoc.save();
+  return Buffer.from(pdfBytes);
+}
+
+// Helper to create a form PDF
+async function createFormPDF() {
+  const pdfDoc = await PDFDocument.create();
+  const page = pdfDoc.addPage();
+
+  // Add form fields
+  const form = pdfDoc.getForm();
+  const textField = form.createTextField("firstName");
+  textField.addToPage(page, { x: 50, y: 500, width: 200, height: 25 });
+
+  const checkboxField = form.createCheckBox("agreeToTerms");
+  checkboxField.addToPage(page, { x: 50, y: 400, width: 25, height: 25 });
+
+  const pdfBytes = await pdfDoc.save();
+  return Buffer.from(pdfBytes);
+}
+
+test("Plugin Registration", async (t) => {
+  await t.test("registers successfully", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF);
+    assert.ok(fastify.xPDF);
+    assert.equal(typeof fastify.xPDF.generateFromHtml, "function");
+    assert.equal(typeof fastify.xPDF.generateFromMarkdown, "function");
+    assert.equal(typeof fastify.xPDF.fillForm, "function");
+    assert.equal(typeof fastify.xPDF.listFormFields, "function");
+    assert.equal(typeof fastify.xPDF.mergePDFs, "function");
+    await fastify.close();
+  });
+
+  await t.test("uses default configuration", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF);
+    assert.ok(fastify.xPDF);
+    await fastify.close();
+  });
+
+  await t.test("accepts custom configuration", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF, {
+      headless: true,
+      format: "Letter",
+      margin: { top: "0.5in", right: "0.5in", bottom: "0.5in", left: "0.5in" },
+    });
+    assert.ok(fastify.xPDF);
+    await fastify.close();
+  });
+
+  await t.test("cleans up browser on close", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF);
+
+    // Generate one PDF to initialize browser
+    await fastify.xPDF.generateFromHtml("<h1>Test</h1>");
+
+    // Browser should exist
+    assert.ok(fastify.xPDF);
+
+    // Close should not throw
+    await fastify.close();
+  });
+});
+
+test("HTML to PDF Generation", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("generates PDF from simple HTML", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Hello</h1>");
+
+    assert.ok(result.buffer);
+    assert.ok(Buffer.isBuffer(result.buffer));
+    assert.ok(result.filename.includes(".pdf"));
+    assert.ok(result.size > 0);
+    assert.equal(result.buffer[0], 0x25); // PDF header: %
+    assert.equal(result.buffer[1], 0x50); // PDF header: P
+    assert.equal(result.buffer[2], 0x44); // PDF header: D
+    assert.equal(result.buffer[3], 0x46); // PDF header: F
+  });
+
+  await t.test("accepts custom filename", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>", {
+      filename: "custom-name.pdf",
+    });
+
+    assert.equal(result.filename, "custom-name.pdf");
+  });
+
+  await t.test("accepts custom format", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>", {
+      format: "Letter",
+    });
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("accepts landscape orientation", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>", {
+      landscape: true,
+    });
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("accepts custom margins", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>", {
+      margin: {
+        top: "2cm",
+        right: "1cm",
+        bottom: "2cm",
+        left: "1cm",
+      },
+    });
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("rejects empty HTML", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.generateFromHtml(""),
+      { message: /HTML content must be a non-empty string/ }
+    );
+  });
+
+  await t.test("rejects non-string HTML", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.generateFromHtml(null),
+      { message: /HTML content must be a non-empty string/ }
+    );
+  });
+});
+
+test("Markdown to PDF Generation", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("generates PDF from Markdown", async () => {
+    const markdown = "# Heading\n\nParagraph with **bold** and *italic*.";
+    const result = await fastify.xPDF.generateFromMarkdown(markdown);
+
+    assert.ok(result.buffer);
+    assert.ok(Buffer.isBuffer(result.buffer));
+    assert.ok(result.filename.includes(".pdf"));
+  });
+
+  await t.test("converts common Markdown features", async () => {
+    const markdown = `
+# Heading 1
+## Heading 2
+
+Paragraph with **bold** and *italic* and \`code\`.
+
+- List item 1
+- List item 2
+
+1. Numbered item 1
+2. Numbered item 2
+
+\`\`\`javascript
+console.log("Code block");
+\`\`\`
+
+> Blockquote
+
+[Link](https://example.com)
+`;
+    const result = await fastify.xPDF.generateFromMarkdown(markdown);
+
+    assert.ok(result.buffer);
+    assert.ok(result.size > 0);
+  });
+
+  await t.test("accepts custom filename", async () => {
+    const result = await fastify.xPDF.generateFromMarkdown("# Test", {
+      filename: "custom.pdf",
+    });
+
+    assert.equal(result.filename, "custom.pdf");
+  });
+
+  await t.test("rejects empty Markdown", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.generateFromMarkdown(""),
+      { message: /Markdown content must be a non-empty string/ }
+    );
+  });
+
+  await t.test("rejects non-string Markdown", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.generateFromMarkdown(null),
+      { message: /Markdown content must be a non-empty string/ }
+    );
+  });
+});
+
+test("PDF Form Filling", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("fills text field in PDF form", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const result = await fastify.xPDF.fillForm(
+      pdfBuffer,
+      { firstName: "John" },
+      {
+        flatten: false,
+      }
+    );
+
+    assert.ok(result.buffer);
+    assert.ok(Buffer.isBuffer(result.buffer));
+    assert.ok(result.filename.includes(".pdf"));
+  });
+
+  await t.test("fills checkbox field in PDF form", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const result = await fastify.xPDF.fillForm(
+      pdfBuffer,
+      { agreeToTerms: true },
+      {
+        flatten: false,
+      }
+    );
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("flattens form after filling", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const result = await fastify.xPDF.fillForm(
+      pdfBuffer,
+      { firstName: "Jane" },
+      {
+        flatten: true,
+      }
+    );
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("accepts custom filename", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const result = await fastify.xPDF.fillForm(
+      pdfBuffer,
+      { firstName: "Test" },
+      {
+        filename: "custom-form.pdf",
+      }
+    );
+
+    assert.equal(result.filename, "custom-form.pdf");
+  });
+
+  await t.test("rejects invalid PDF buffer", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.fillForm(Buffer.from("not a pdf"), {}),
+      { message: /Invalid PDF buffer/ }
+    );
+  });
+
+  await t.test("rejects non-buffer input", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.fillForm(null, {}),
+      { message: /Invalid PDF buffer/ }
+    );
+  });
+});
+
+test("PDF Form Field Listing", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("lists form fields in PDF", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const fields = await fastify.xPDF.listFormFields(pdfBuffer);
+
+    assert.ok(Array.isArray(fields));
+    assert.ok(fields.length > 0);
+    assert.ok(fields.some((f) => f.name === "firstName"));
+  });
+
+  await t.test("returns field information", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const fields = await fastify.xPDF.listFormFields(pdfBuffer);
+
+    for (const field of fields) {
+      assert.ok(field.name);
+      assert.ok(field.type);
+    }
+  });
+
+  await t.test("rejects invalid PDF buffer", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.listFormFields(Buffer.from("not a pdf")),
+      { message: /Invalid PDF buffer/ }
+    );
+  });
+});
+
+test("PDF Merging", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("merges two PDFs", async () => {
+    const pdf1 = await createSimplePDF();
+    const pdf2 = await createSimplePDF();
+
+    const result = await fastify.xPDF.mergePDFs([pdf1, pdf2]);
+
+    assert.ok(result.buffer);
+    assert.ok(Buffer.isBuffer(result.buffer));
+    assert.ok(result.filename.includes(".pdf"));
+    assert.ok(result.pageCount > 0);
+  });
+
+  await t.test("merges multiple PDFs", async () => {
+    const pdfs = [
+      await createSimplePDF(),
+      await createSimplePDF(),
+      await createSimplePDF(),
+    ];
+
+    const result = await fastify.xPDF.mergePDFs(pdfs);
+
+    assert.ok(result.buffer);
+    assert.ok(result.pageCount >= 3);
+  });
+
+  await t.test("accepts custom filename", async () => {
+    const pdfs = [await createSimplePDF(), await createSimplePDF()];
+
+    const result = await fastify.xPDF.mergePDFs(pdfs, {
+      filename: "custom-merged.pdf",
+    });
+
+    assert.equal(result.filename, "custom-merged.pdf");
+  });
+
+  await t.test("rejects empty array", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.mergePDFs([]),
+      { message: /pdfBuffers must be a non-empty array/ }
+    );
+  });
+
+  await t.test("rejects invalid PDF in array", async () => {
+    const validPDF = await createSimplePDF();
+    const invalidPDF = Buffer.from("not a pdf");
+
+    await assert.rejects(
+      () => fastify.xPDF.mergePDFs([validPDF, invalidPDF]),
+      { message: /invalid PDF buffers/ }
+    );
+  });
+
+  await t.test("rejects non-array input", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.mergePDFs(null),
+      { message: /pdfBuffers must be a non-empty array/ }
+    );
+  });
+});
+
+test("Error Handling", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("handles empty string gracefully", async () => {
+    await assert.rejects(
+      () => fastify.xPDF.generateFromHtml(""),
+      { message: /HTML content must be a non-empty string/ }
+    );
+  });
+
+  await t.test("handles multiple concurrent operations", async () => {
+    const operations = Array(5)
+      .fill(null)
+      .map(() => fastify.xPDF.generateFromHtml("<h1>Test</h1>"));
+
+    const results = await Promise.all(operations);
+
+    assert.equal(results.length, 5);
+    assert.ok(results.every((r) => Buffer.isBuffer(r.buffer)));
+  });
+});
+
+test("Configuration Options", async (t) => {
+  await t.test("uses default configuration", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF);
+    assert.ok(fastify.xPDF);
+    await fastify.close();
+  });
+
+  await t.test("uses custom headless setting", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF, {
+      headless: true,
+    });
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>");
+    assert.ok(result.buffer);
+    await fastify.close();
+  });
+
+  await t.test("uses custom page format", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF, {
+      format: "Letter",
+    });
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>");
+    assert.ok(result.buffer);
+    await fastify.close();
+  });
+
+  await t.test("uses custom margins", async () => {
+    const fastify = Fastify();
+    await fastify.register(xPDF, {
+      margin: {
+        top: "2cm",
+        right: "1cm",
+        bottom: "2cm",
+        left: "1cm",
+      },
+    });
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>");
+    assert.ok(result.buffer);
+    await fastify.close();
+  });
+});
+
+test("Return Value Structure", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("generateFromHtml returns correct structure", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>");
+
+    assert.ok(result.buffer);
+    assert.ok(result.filename);
+    assert.ok(typeof result.size === "number");
+    assert.ok(result.size > 0);
+  });
+
+  await t.test("generateFromMarkdown returns correct structure", async () => {
+    const result = await fastify.xPDF.generateFromMarkdown("# Test");
+
+    assert.ok(result.buffer);
+    assert.ok(result.filename);
+    assert.ok(typeof result.size === "number");
+  });
+
+  await t.test("fillForm returns correct structure", async () => {
+    const pdfBuffer = await createFormPDF();
+    const result = await fastify.xPDF.fillForm(pdfBuffer, {});
+
+    assert.ok(result.buffer);
+    assert.ok(result.filename);
+    assert.ok(typeof result.size === "number");
+  });
+
+  await t.test("mergePDFs returns correct structure", async () => {
+    const pdfs = [await createSimplePDF(), await createSimplePDF()];
+    const result = await fastify.xPDF.mergePDFs(pdfs);
+
+    assert.ok(result.buffer);
+    assert.ok(result.filename);
+    assert.ok(typeof result.size === "number");
+    assert.ok(typeof result.pageCount === "number");
+  });
+});
+
+test("Helper Utilities", async (t) => {
+  const { helpers } = await import("../src/index.js");
+
+  await t.test("generatePdfFilename creates unique names", async () => {
+    const name1 = helpers.generatePdfFilename("test");
+    // Add small delay to ensure different timestamp
+    await new Promise(resolve => setTimeout(resolve, 2));
+    const name2 = helpers.generatePdfFilename("test");
+
+    assert.ok(name1.startsWith("test-"));
+    assert.ok(name2.startsWith("test-"));
+    assert.ok(name1.endsWith(".pdf"));
+    assert.notEqual(name1, name2); // Should be unique (different timestamps)
+  });
+
+  await t.test("isValidPdfBuffer validates PDF buffers", async () => {
+    const validPDF = await createSimplePDF();
+    const invalidBuffer = Buffer.from("not a pdf");
+    const notBuffer = "string";
+
+    assert.ok(helpers.isValidPdfBuffer(validPDF));
+    assert.ok(!helpers.isValidPdfBuffer(invalidBuffer));
+    assert.ok(!helpers.isValidPdfBuffer(notBuffer));
+  });
+
+  await t.test("getPdfMetadata returns correct info", async () => {
+    const pdfBuffer = await createSimplePDF();
+    const metadata = helpers.getPdfMetadata(pdfBuffer);
+
+    assert.ok(metadata.size > 0);
+    assert.equal(metadata.size, pdfBuffer.length);
+  });
+
+  await t.test("sanitizeFilename sanitizes unsafe characters", async () => {
+    const result = helpers.sanitizeFilename("My File (2024) @#$.pdf");
+
+    assert.ok(result.length > 0);
+    assert.ok(result === result.toLowerCase());
+    assert.ok(!result.includes("@"));
+    assert.ok(!result.includes("#"));
+    assert.ok(!result.includes("$"));
+  });
+
+  await t.test("getPageFormat returns correct dimensions", async () => {
+    const a4 = helpers.getPageFormat("A4");
+    const letter = helpers.getPageFormat("Letter");
+    const a3 = helpers.getPageFormat("A3");
+
+    assert.ok(a4.width > 0 && a4.height > 0);
+    assert.ok(letter.width > 0 && letter.height > 0);
+    assert.ok(a3.width > 0 && a3.height > 0);
+    assert.ok(a3.width > a4.width); // A3 should be larger
+  });
+
+  await t.test("parseMargin handles different formats", async () => {
+    const objectMargin = helpers.parseMargin({
+      top: "1cm",
+      right: "2cm",
+      bottom: "1cm",
+      left: "2cm",
+    });
+    const stringMargin = helpers.parseMargin("1cm");
+
+    assert.equal(objectMargin.top, "1cm");
+    assert.equal(objectMargin.right, "2cm");
+    assert.equal(stringMargin.top, "1cm");
+    assert.equal(stringMargin.left, "1cm");
+  });
+});
+
+test("Additional PDF Generation Options", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("printBackground option affects PDF", async () => {
+    const html = "<style>body { background: red; }</style><h1>Test</h1>";
+
+    const withBackground = await fastify.xPDF.generateFromHtml(html, {
+      printBackground: true,
+    });
+
+    const withoutBackground = await fastify.xPDF.generateFromHtml(html, {
+      printBackground: false,
+    });
+
+    // Both should generate valid PDFs (size may differ due to background)
+    assert.ok(withBackground.buffer);
+    assert.ok(withoutBackground.buffer);
+  });
+
+  await t.test("generates with A3 format", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>", {
+      format: "A3",
+    });
+
+    assert.ok(result.buffer);
+    assert.ok(result.size > 0);
+  });
+
+  await t.test("generates with small A5 format", async () => {
+    const result = await fastify.xPDF.generateFromHtml("<h1>Test</h1>", {
+      format: "A5",
+    });
+
+    assert.ok(result.buffer);
+    assert.ok(result.size > 0);
+  });
+
+  await t.test("handles complex HTML with tables", async () => {
+    const html = `
+      <table>
+        <tr><th>Col 1</th><th>Col 2</th></tr>
+        <tr><td>Data 1</td><td>Data 2</td></tr>
+        <tr><td>Data 3</td><td>Data 4</td></tr>
+      </table>
+    `;
+
+    const result = await fastify.xPDF.generateFromHtml(html);
+
+    assert.ok(result.buffer);
+    assert.ok(result.size > 0);
+  });
+
+  await t.test("handles HTML with inline styles", async () => {
+    const html = `
+      <h1 style="color: blue; text-align: center;">Styled Title</h1>
+      <p style="font-size: 14px; line-height: 1.8;">Paragraph</p>
+    `;
+
+    const result = await fastify.xPDF.generateFromHtml(html);
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("handles Markdown with code blocks", async () => {
+    const markdown = `
+# Code Example
+
+\`\`\`javascript
+function test() {
+  console.log("Hello");
+}
+\`\`\`
+
+\`\`\`python
+def test():
+    print("Hello")
+\`\`\`
+`;
+
+    const result = await fastify.xPDF.generateFromMarkdown(markdown);
+
+    assert.ok(result.buffer);
+  });
+});
+
+test("PDF Form Advanced Tests", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("handles missing form fields gracefully", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const result = await fastify.xPDF.fillForm(
+      pdfBuffer,
+      {
+        firstName: "John",
+        nonExistentField: "value",
+      },
+      {
+        flatten: false,
+      }
+    );
+
+    assert.ok(result.buffer); // Should still return valid PDF
+  });
+
+  await t.test("can fill form without flattening", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const result = await fastify.xPDF.fillForm(
+      pdfBuffer,
+      { firstName: "Jane" },
+      {
+        flatten: false,
+      }
+    );
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("fillForm with empty field values", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const result = await fastify.xPDF.fillForm(pdfBuffer, {}, {
+      flatten: true,
+    });
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("multiple concurrent form fills", async () => {
+    const pdfBuffer = await createFormPDF();
+
+    const operations = Array(3)
+      .fill(null)
+      .map((_, i) =>
+        fastify.xPDF.fillForm(
+          pdfBuffer,
+          { firstName: `Person${i}` },
+          {
+            flatten: true,
+            filename: `form-${i}.pdf`,
+          }
+        )
+      );
+
+    const results = await Promise.all(operations);
+
+    assert.equal(results.length, 3);
+    assert.ok(results.every((r) => Buffer.isBuffer(r.buffer)));
+    assert.ok(results.every((r) => r.filename.startsWith("form-")));
+  });
+});
+
+test("PDF Merging Advanced Tests", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("merges large number of PDFs", async () => {
+    const pdfs = await Promise.all(
+      Array(10)
+        .fill(null)
+        .map(() => createSimplePDF())
+    );
+
+    const result = await fastify.xPDF.mergePDFs(pdfs);
+
+    assert.ok(result.buffer);
+    assert.ok(result.pageCount >= 10);
+  });
+
+  await t.test("merge result is valid PDF", async () => {
+    const pdfs = [await createSimplePDF(), await createSimplePDF()];
+    const result = await fastify.xPDF.mergePDFs(pdfs);
+
+    // Verify PDF header
+    assert.equal(result.buffer[0], 0x25); // %
+    assert.equal(result.buffer[1], 0x50); // P
+    assert.equal(result.buffer[2], 0x44); // D
+    assert.equal(result.buffer[3], 0x46); // F
+  });
+
+  await t.test("merge preserves content order", async () => {
+    const pdf1 = await createSimplePDF();
+    const pdf2 = await createSimplePDF();
+
+    const result = await fastify.xPDF.mergePDFs([pdf1, pdf2], {
+      filename: "ordered-merge.pdf",
+    });
+
+    assert.ok(result.buffer);
+    assert.equal(result.filename, "ordered-merge.pdf");
+  });
+});
+
+test("Edge Cases and Stress Tests", async (t) => {
+  let fastify;
+
+  t.before(async () => {
+    fastify = Fastify();
+    await fastify.register(xPDF);
+  });
+
+  t.after(async () => {
+    await fastify.close();
+  });
+
+  await t.test("handles high volume of concurrent HTML to PDF", async () => {
+    const operations = Array(5)
+      .fill(null)
+      .map(() => fastify.xPDF.generateFromHtml("<h1>Test</h1>"));
+
+    const results = await Promise.all(operations);
+
+    assert.equal(results.length, 5);
+    assert.ok(results.every((r) => Buffer.isBuffer(r.buffer)));
+    assert.ok(results.every((r) => r.size > 0));
+  });
+
+  await t.test("handles very long HTML content", async () => {
+    const longContent = `<h1>Start</h1>${Array(100)
+      .fill('<p>Paragraph content</p>')
+      .join("")}<h1>End</h1>`;
+
+    const result = await fastify.xPDF.generateFromHtml(longContent);
+
+    assert.ok(result.buffer);
+    assert.ok(result.size > 1000); // Should be reasonably large
+  });
+
+  await t.test("handles Unicode content in HTML", async () => {
+    const unicodeHtml = `
+      <h1>Unicode Test</h1>
+      <p>English: Hello</p>
+      <p>Japanese: こんにちは</p>
+      <p>Arabic: مرحبا</p>
+      <p>Emoji: 🎉 🚀 ✨</p>
+    `;
+
+    const result = await fastify.xPDF.generateFromHtml(unicodeHtml);
+
+    assert.ok(result.buffer);
+  });
+
+  await t.test("handles Unicode content in Markdown", async () => {
+    const unicodeMarkdown = `
+# Unicode Test
+
+- English: Hello
+- Japanese: こんにちは
+- Arabic: مرحبا
+- Emoji: 🎉 🚀 ✨
+    `;
+
+    const result = await fastify.xPDF.generateFromMarkdown(unicodeMarkdown);
+
+    assert.ok(result.buffer);
+  });
+});