@jaredwray/mockhttp 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -7,6 +7,7 @@ type HttpBinOptions = {
     requestInspection?: boolean;
     responseInspection?: boolean;
     statusCodes?: boolean;
+    responseFormats?: boolean;
     cookies?: boolean;
     anything?: boolean;
     auth?: boolean;
@@ -155,6 +156,7 @@ declare class MockHttp extends Hookified {
      * @param fastifyInstance - the server instance to register the routes on.
      */
     registerResponseInspectionRoutes(fastifyInstance?: FastifyInstance): Promise<void>;
+    registerResponseFormatRoutes(fastifyInstance?: FastifyInstance): Promise<void>;
     /**
      * Register the redirect routes.
      * @param fastifyInstance - the server instance to register the routes on.

package/dist/index.js

@@ -1296,156 +1296,114 @@ var userAgentRoute = /* @__PURE__ */ __name((fastify) => {
   });
 }, "userAgentRoute");
 
-// src/routes/response-inspection/cache.ts
-var cacheGetSchema = {
-  description: "Handles cache validation and retrieval.",
+// src/routes/response-formats/index.ts
+import { brotliCompressSync, deflateSync, gzipSync } from "zlib";
+var plainSchema = {
+  description: "Returns random plain text content",
   tags: [
-    "Response Inspection"
+    "Response Formats"
   ],
   response: {
     200: {
       type: "string",
-      description: "The cached content or resource."
-    },
-    304: {
-      type: "null",
-      description: "Indicates the resource has not been modified."
+      description: "Random plain text content"
     }
   }
 };
-var cacheSetSchema = {
-  description: "Sets a Cache-Control header for n seconds.",
+var textSchema = {
+  description: "Returns random text content",
   tags: [
-    "Response Inspection"
+    "Response Formats"
   ],
-  params: {
-    type: "object",
-    properties: {
-      value: {
-        type: "integer",
-        description: "Number of seconds to cache the resource."
-      }
-    },
-    required: [
-      "value"
-    ]
-  },
   response: {
     200: {
       type: "string",
-      description: "Confirmation message for setting cache."
+      description: "Random text content"
     }
   }
 };
-var cacheRoutes = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/cache", {
-    schema: cacheGetSchema
-  }, async (request, reply) => {
-    const ifModifiedSince = request.headers["if-modified-since"];
-    const ifNoneMatch = request.headers["if-none-match"];
-    if (ifModifiedSince ?? ifNoneMatch) {
-      await reply.status(304).send();
-      return;
+var htmlSchema = {
+  description: "Returns random HTML content",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "Random HTML content"
     }
-    await reply.send("Cache content or resource response here.");
-  });
-  fastify.get("/cache/:value", {
-    schema: cacheSetSchema
-  }, async (request, reply) => {
-    const { value } = request.params;
-    await reply.header("Cache-Control", `max-age=${value}`).send(`Cache-Control set for ${value} seconds.`);
-  });
-}, "cacheRoutes");
-
-// src/routes/response-inspection/etag.ts
-var etagSchema = {
-  description: "Handles ETag-based conditional requests.",
+  }
+};
+var xmlSchema = {
+  description: "Returns random XML content",
   tags: [
-    "Response Inspection"
+    "Response Formats"
   ],
-  params: {
-    type: "object",
-    properties: {
-      etag: {
-        type: "string",
-        description: "The ETag value for the resource."
-      }
-    },
-    required: [
-      "etag"
-    ]
-  },
   response: {
     200: {
       type: "string",
-      description: "Resource content for matching ETag."
-    },
-    304: {
-      type: "null",
-      description: "Indicates the resource has not been modified."
-    },
-    412: {
-      type: "null",
-      description: "Indicates a precondition failed due to mismatched ETag."
+      description: "Random XML content"
     }
   }
 };
-var etagRoutes = /* @__PURE__ */ __name((fastify) => {
-  fastify.get("/etag/:etag", {
-    schema: etagSchema
-  }, async (request, reply) => {
-    const { etag } = request.params;
-    const ifNoneMatch = request.headers["if-none-match"];
-    const ifMatch = request.headers["if-match"];
-    if (ifNoneMatch === etag) {
-      await reply.status(304).send();
-      return;
+var jsonSchema = {
+  description: "Returns random JSON content",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    200: {
+      type: "object",
+      description: "Random JSON content",
+      additionalProperties: true
     }
-    if (ifMatch && ifMatch !== etag) {
-      await reply.status(412).send();
-      return;
+  }
+};
+var denySchema = {
+  description: "Returns page denied by robots.txt rules",
+  tags: [
+    "Response Formats"
+  ],
+  response: {
+    403: {
+      type: "string",
+      description: "Page denied by robots.txt rules"
     }
-    await reply.header("ETag", etag).send("Resource content for matching ETag.");
-  });
-}, "etagRoutes");
-
-// src/routes/response-inspection/plain.ts
-var plainSchema = {
-  description: "Returns random plain text content",
+  }
+};
+var gzipSchema = {
+  description: "Returns GZip-encoded data",
   tags: [
-    "Response Inspection"
+    "Response Formats"
   ],
-  // @ts-expect-error
   response: {
     200: {
       type: "string",
-      description: "Random plain text content"
+      description: "GZip-encoded content"
     }
   }
 };
-var textSchema = {
-  description: "Returns random text content",
+var deflateSchema = {
+  description: "Returns Deflate-encoded data",
   tags: [
-    "Response Inspection"
+    "Response Formats"
   ],
-  // @ts-expect-error
   response: {
     200: {
       type: "string",
-      description: "Random text content"
+      description: "Deflate-encoded content"
     }
   }
 };
-var htmlSchema = {
-  description: "Returns random HTML content",
+var brotliSchema = {
+  description: "Returns Brotli-encoded data",
   tags: [
-    "Response Inspection"
+    "Response Formats"
   ],
-  // @ts-expect-error
   response: {
     200: {
       type: "string",
-      description: "Random HTML content"
+      description: "Brotli-encoded content"
     }
   }
 };
@@ -1547,47 +1505,636 @@ var randomHtmlContent = [
 </body>
 </html>`
 ];
-var plainRoute = /* @__PURE__ */ __name((fastify) => {
-  fastify.get(
-    "/plain",
-    {
-      schema: plainSchema
+var randomXmlContent = [
+  `<?xml version="1.0" encoding="UTF-8"?>
+<root>
+    <message>Hello from MockHTTP</message>
+    <timestamp>${(/* @__PURE__ */ new Date()).toISOString()}</timestamp>
+    <status>success</status>
+</root>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
+<book>
+    <title>The Great Gatsby</title>
+    <author>F. Scott Fitzgerald</author>
+    <year>1925</year>
+    <publisher>Charles Scribner's Sons</publisher>
+    <isbn>978-0-7432-7356-5</isbn>
+</book>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
+<users>
+    <user id="1">
+        <name>John Doe</name>
+        <email>john@example.com</email>
+        <role>admin</role>
+    </user>
+    <user id="2">
+        <name>Jane Smith</name>
+        <email>jane@example.com</email>
+        <role>user</role>
+    </user>
+</users>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
+<product>
+    <id>12345</id>
+    <name>Wireless Mouse</name>
+    <description>Ergonomic wireless mouse with 3-year battery life</description>
+    <price currency="USD">29.99</price>
+    <stock>150</stock>
+    <category>Electronics</category>
+</product>`,
+  `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+    <channel>
+        <title>Mock RSS Feed</title>
+        <link>http://example.com/rss</link>
+        <description>Sample RSS feed from MockHTTP</description>
+        <item>
+            <title>First Article</title>
+            <link>http://example.com/article1</link>
+            <description>This is the first article in our feed</description>
+            <pubDate>${(/* @__PURE__ */ new Date()).toUTCString()}</pubDate>
+        </item>
+    </channel>
+</rss>`
+];
+var randomJsonContent = [
+  () => ({
+    message: "Hello from MockHTTP",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "success",
+    code: 200
+  }),
+  () => ({
+    user: {
+      id: 1,
+      name: "John Doe",
+      email: "john@example.com",
+      role: "admin",
+      createdAt: "2024-01-15T10:30:00Z"
+    },
+    permissions: [
+      "read",
+      "write",
+      "delete"
+    ]
+  }),
+  () => ({
+    products: [
+      {
+        id: 101,
+        name: "Laptop",
+        price: 999.99,
+        stock: 50
+      },
+      {
+        id: 102,
+        name: "Mouse",
+        price: 29.99,
+        stock: 200
+      }
+    ],
+    total: 2,
+    page: 1
+  }),
+  () => ({
+    config: {
+      theme: "dark",
+      language: "en",
+      notifications: {
+        email: true,
+        push: false,
+        sms: false
+      },
+      privacy: {
+        profile: "public",
+        activity: "friends"
+      }
+    }
+  }),
+  () => ({
+    metrics: {
+      cpu: 45.2,
+      memory: 78.5,
+      disk: 62.3,
+      network: {
+        inbound: "1.2MB/s",
+        outbound: "0.8MB/s"
+      },
+      uptime: "15 days",
+      services: [
+        {
+          name: "api",
+          status: "healthy"
+        },
+        {
+          name: "database",
+          status: "healthy"
+        },
+        {
+          name: "cache",
+          status: "warning"
+        }
+      ]
+    }
+  })
+];
+var responseFormatRoutes = /* @__PURE__ */ __name((fastify) => {
+  const plainHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomTexts.length);
+    const text = randomTexts[randomIndex];
+    reply.type("text/plain");
+    return text;
+  }, "plainHandler");
+  fastify.get("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.post("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.put("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.patch("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  fastify.delete("/plain", {
+    schema: plainSchema
+  }, plainHandler);
+  const textHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomTexts.length);
+    const text = randomTexts[randomIndex];
+    reply.type("text/plain");
+    return text;
+  }, "textHandler");
+  fastify.get("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.post("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.put("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.patch("/text", {
+    schema: textSchema
+  }, textHandler);
+  fastify.delete("/text", {
+    schema: textSchema
+  }, textHandler);
+  const htmlHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomHtmlContent.length);
+    const html = randomHtmlContent[randomIndex];
+    reply.type("text/html");
+    return html;
+  }, "htmlHandler");
+  fastify.get("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.post("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.put("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.patch("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  fastify.delete("/html", {
+    schema: htmlSchema
+  }, htmlHandler);
+  const xmlHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomXmlContent.length);
+    const xml = randomXmlContent[randomIndex];
+    reply.type("application/xml");
+    return xml;
+  }, "xmlHandler");
+  fastify.get("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.post("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.put("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.patch("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  fastify.delete("/xml", {
+    schema: xmlSchema
+  }, xmlHandler);
+  const jsonHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const randomIndex = Math.floor(Math.random() * randomJsonContent.length);
+    const jsonGenerator = randomJsonContent[randomIndex];
+    const json = jsonGenerator();
+    reply.type("application/json");
+    return json;
+  }, "jsonHandler");
+  fastify.get("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.post("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.put("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.patch("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  fastify.delete("/json", {
+    schema: jsonSchema
+  }, jsonHandler);
+  const denyHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const denyMessages = [
+      `<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+<html><head>
+<title>403 Forbidden</title>
+</head><body>
+<h1>Forbidden</h1>
+<p>Access denied by robots.txt rules.</p>
+<p>The requested resource is disallowed by robots.txt.</p>
+</body></html>`,
+      `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>403 - Access Denied</title>
+</head>
+<body>
+<h1>403 Forbidden</h1>
+<p>This page is blocked by robots.txt rules.</p>
+<p>User-agent: *<br>Disallow: ${_request.url}</p>
+</body>
+</html>`,
+      `<!DOCTYPE html>
+<html>
+<head>
+<title>403 - Access Denied</title>
+<style>body { font-family: Arial, sans-serif; margin: 40px; }</style>
+</head>
+<body>
+<h2>403 - Access Denied by robots.txt</h2>
+<p>The robots.txt file prevents access to this resource.</p>
+<hr>
+<small>MockHTTP Server</small>
+</body>
+</html>`
+    ];
+    const randomIndex = Math.floor(Math.random() * denyMessages.length);
+    const html = denyMessages[randomIndex];
+    reply.code(403);
+    reply.type("text/html");
+    return html;
+  }, "denyHandler");
+  fastify.get("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.post("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.put("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.patch("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  fastify.delete("/deny", {
+    schema: denySchema
+  }, denyHandler);
+  const gzipHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const sampleData = [
+      {
+        message: "This is GZip compressed data from MockHTTP",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        compression: "gzip",
+        originalSize: 0,
+        compressedSize: 0
+      },
+      {
+        title: "Sample Document",
+        content: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".repeat(50),
+        metadata: {
+          author: "MockHTTP Server",
+          format: "gzip",
+          version: "1.0"
+        }
+      },
+      {
+        data: Array.from({
+          length: 100
+        }, (_, i) => ({
+          id: i + 1,
+          value: `Item ${i + 1}`,
+          description: `This is item number ${i + 1} in the dataset`
+        })),
+        info: "Large dataset compressed with GZip"
+      }
+    ];
+    const randomIndex = Math.floor(Math.random() * sampleData.length);
+    const data = sampleData[randomIndex];
+    const jsonString = JSON.stringify(data);
+    if (data.originalSize !== void 0) {
+      data.originalSize = Buffer.byteLength(jsonString);
+    }
+    const compressed = gzipSync(jsonString);
+    if (data.compressedSize !== void 0) {
+      const updatedData = {
+        ...data,
+        compressedSize: compressed.length
+      };
+      const updatedJsonString = JSON.stringify(updatedData);
+      const updatedCompressed = gzipSync(updatedJsonString);
+      reply.header("Content-Encoding", "gzip");
+      reply.header("Content-Type", "application/json");
+      reply.type("application/octet-stream");
+      return updatedCompressed;
+    }
+    reply.header("Content-Encoding", "gzip");
+    reply.header("Content-Type", "application/json");
+    reply.type("application/octet-stream");
+    return compressed;
+  }, "gzipHandler");
+  fastify.get("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.post("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.put("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.patch("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  fastify.delete("/gzip", {
+    schema: gzipSchema
+  }, gzipHandler);
+  const deflateHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const sampleData = [
+      {
+        message: "This is Deflate compressed data from MockHTTP",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        compression: "deflate",
+        originalSize: 0,
+        compressedSize: 0
+      },
+      {
+        title: "Deflate Compressed Document",
+        content: "The deflate algorithm is used for compression. ".repeat(40),
+        details: {
+          algorithm: "DEFLATE",
+          method: "zlib deflate",
+          server: "MockHTTP"
+        }
+      },
+      {
+        items: Array.from({
+          length: 50
+        }, (_, i) => ({
+          index: i,
+          name: `Entry ${i}`,
+          data: `This is test data for entry number ${i}`,
+          timestamp: new Date(Date.now() - i * 1e6).toISOString()
+        })),
+        metadata: {
+          compression: "deflate",
+          count: 50
+        }
+      }
+    ];
+    const randomIndex = Math.floor(Math.random() * sampleData.length);
+    const data = sampleData[randomIndex];
+    const jsonString = JSON.stringify(data);
+    if (data.originalSize !== void 0) {
+      data.originalSize = Buffer.byteLength(jsonString);
+    }
+    const compressed = deflateSync(jsonString);
+    if (data.compressedSize !== void 0) {
+      const updatedData = {
+        ...data,
+        compressedSize: compressed.length
+      };
+      const updatedJsonString = JSON.stringify(updatedData);
+      const updatedCompressed = deflateSync(updatedJsonString);
+      reply.header("Content-Encoding", "deflate");
+      reply.header("Content-Type", "application/json");
+      reply.type("application/octet-stream");
+      return updatedCompressed;
+    }
+    reply.header("Content-Encoding", "deflate");
+    reply.header("Content-Type", "application/json");
+    reply.type("application/octet-stream");
+    return compressed;
+  }, "deflateHandler");
+  fastify.get("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.post("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.put("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.patch("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  fastify.delete("/deflate", {
+    schema: deflateSchema
+  }, deflateHandler);
+  const brotliHandler = /* @__PURE__ */ __name(async (_request, reply) => {
+    const sampleData = [
+      {
+        message: "This is Brotli compressed data from MockHTTP",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        compression: "br",
+        algorithm: "Brotli",
+        originalSize: 0,
+        compressedSize: 0
+      },
+      {
+        title: "Brotli Compression Example",
+        description: "Brotli is a generic-purpose lossless compression algorithm that compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding and 2nd order context modeling.",
+        content: "Brotli compression typically achieves 20-26% better compression ratios than gzip. ".repeat(10),
+        metadata: {
+          encoding: "br",
+          quality: 11,
+          server: "MockHTTP"
+        }
+      },
+      {
+        benchmark: {
+          title: "Compression Benchmark Data",
+          results: Array.from({
+            length: 75
+          }, (_, i) => ({
+            id: `test-${i}`,
+            name: `Benchmark Test ${i}`,
+            value: Math.random() * 1e3,
+            unit: "ms",
+            timestamp: new Date(Date.now() - i * 6e4).toISOString()
+          })),
+          summary: {
+            compression: "brotli",
+            totalTests: 75,
+            encoding: "br"
+          }
+        }
+      }
+    ];
+    const randomIndex = Math.floor(Math.random() * sampleData.length);
+    const data = sampleData[randomIndex];
+    const jsonString = JSON.stringify(data);
+    if (data.originalSize !== void 0) {
+      data.originalSize = Buffer.byteLength(jsonString);
+    }
+    const compressed = brotliCompressSync(jsonString);
+    if (data.compressedSize !== void 0) {
+      const updatedData = {
+        ...data,
+        compressedSize: compressed.length
+      };
+      const updatedJsonString = JSON.stringify(updatedData);
+      const updatedCompressed = brotliCompressSync(updatedJsonString);
+      reply.header("Content-Encoding", "br");
+      reply.header("Content-Type", "application/json");
+      reply.type("application/octet-stream");
+      return updatedCompressed;
+    }
+    reply.header("Content-Encoding", "br");
+    reply.header("Content-Type", "application/json");
+    reply.type("application/octet-stream");
+    return compressed;
+  }, "brotliHandler");
+  fastify.get("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.post("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.put("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.patch("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+  fastify.delete("/brotli", {
+    schema: brotliSchema
+  }, brotliHandler);
+}, "responseFormatRoutes");
+
+// src/routes/response-inspection/cache.ts
+var cacheGetSchema = {
+  description: "Handles cache validation and retrieval.",
+  tags: [
+    "Response Inspection"
+  ],
+  response: {
+    200: {
+      type: "string",
+      description: "The cached content or resource."
+    },
+    304: {
+      type: "null",
+      description: "Indicates the resource has not been modified."
+    }
+  }
+};
+var cacheSetSchema = {
+  description: "Sets a Cache-Control header for n seconds.",
+  tags: [
+    "Response Inspection"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      value: {
+        type: "integer",
+        description: "Number of seconds to cache the resource."
+      }
+    },
+    required: [
+      "value"
+    ]
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Confirmation message for setting cache."
+    }
+  }
+};
+var cacheRoutes = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/cache", {
+    schema: cacheGetSchema
+  }, async (request, reply) => {
+    const ifModifiedSince = request.headers["if-modified-since"];
+    const ifNoneMatch = request.headers["if-none-match"];
+    if (ifModifiedSince ?? ifNoneMatch) {
+      await reply.status(304).send();
+      return;
+    }
+    await reply.send("Cache content or resource response here.");
+  });
+  fastify.get("/cache/:value", {
+    schema: cacheSetSchema
+  }, async (request, reply) => {
+    const { value } = request.params;
+    await reply.header("Cache-Control", `max-age=${value}`).send(`Cache-Control set for ${value} seconds.`);
+  });
+}, "cacheRoutes");
+
+// src/routes/response-inspection/etag.ts
+var etagSchema = {
+  description: "Handles ETag-based conditional requests.",
+  tags: [
+    "Response Inspection"
+  ],
+  params: {
+    type: "object",
+    properties: {
+      etag: {
+        type: "string",
+        description: "The ETag value for the resource."
+      }
     },
-    // biome-ignore lint/suspicious/noExplicitAny: reply
-    async (_request, reply) => {
-      const randomIndex = Math.floor(Math.random() * randomTexts.length);
-      const text = randomTexts[randomIndex];
-      reply.type("text/plain");
-      return text;
-    }
-  );
-  fastify.get(
-    "/text",
-    {
-      schema: textSchema
+    required: [
+      "etag"
+    ]
+  },
+  response: {
+    200: {
+      type: "string",
+      description: "Resource content for matching ETag."
     },
-    // biome-ignore lint/suspicious/noExplicitAny: reply
-    async (_request, reply) => {
-      const randomIndex = Math.floor(Math.random() * randomTexts.length);
-      const text = randomTexts[randomIndex];
-      reply.type("text/plain");
-      return text;
-    }
-  );
-  fastify.get(
-    "/html",
-    {
-      schema: htmlSchema
+    304: {
+      type: "null",
+      description: "Indicates the resource has not been modified."
     },
-    // biome-ignore lint/suspicious/noExplicitAny: reply
-    async (_request, reply) => {
-      const randomIndex = Math.floor(Math.random() * randomHtmlContent.length);
-      const html = randomHtmlContent[randomIndex];
-      reply.type("text/html");
-      return html;
-    }
-  );
-}, "plainRoute");
+    412: {
+      type: "null",
+      description: "Indicates a precondition failed due to mismatched ETag."
+    }
+  }
+};
+var etagRoutes = /* @__PURE__ */ __name((fastify) => {
+  fastify.get("/etag/:etag", {
+    schema: etagSchema
+  }, async (request, reply) => {
+    const { etag } = request.params;
+    const ifNoneMatch = request.headers["if-none-match"];
+    const ifMatch = request.headers["if-match"];
+    if (ifNoneMatch === etag) {
+      await reply.status(304).send();
+      return;
+    }
+    if (ifMatch && ifMatch !== etag) {
+      await reply.status(412).send();
+      return;
+    }
+    await reply.header("ETag", etag).send("Resource content for matching ETag.");
+  });
+}, "etagRoutes");
 
 // src/routes/response-inspection/response-headers.ts
 import { escape as escapeHtml } from "html-escaper";
@@ -1988,7 +2535,7 @@ import { fastifySwaggerUi } from "@fastify/swagger-ui";
 // package.json
 var package_default = {
   name: "@jaredwray/mockhttp",
-  version: "0.8.0",
+  version: "0.9.0",
   description: "Mock Http - Easy way to mock http with httpbin replacement",
   type: "module",
   main: "dist/index.js",
@@ -2130,6 +2677,7 @@ var MockHttp = class extends Hookified {
     redirects: true,
     requestInspection: true,
     responseInspection: true,
+    responseFormats: true,
     statusCodes: true,
     cookies: true,
     anything: true,
@@ -2272,7 +2820,7 @@ var MockHttp = class extends Hookified {
       if (this._apiDocs) {
         await this.registerApiDocs();
       }
-      const { httpMethods, redirects, requestInspection, responseInspection, statusCodes: statusCodes2, cookies, anything, auth } = this._httpBin;
+      const { httpMethods, redirects, requestInspection, responseInspection, responseFormats, statusCodes: statusCodes2, cookies, anything, auth } = this._httpBin;
       if (httpMethods) {
         await this.registerHttpMethods();
       }
@@ -2285,6 +2833,9 @@ var MockHttp = class extends Hookified {
       if (responseInspection) {
         await this.registerResponseInspectionRoutes();
       }
+      if (responseFormats) {
+        await this.registerResponseFormatRoutes();
+      }
       if (redirects) {
         await this.registerRedirectRoutes();
       }
@@ -2374,9 +2925,12 @@ var MockHttp = class extends Hookified {
     const fastify = fastifyInstance ?? this._server;
     await fastify.register(cacheRoutes);
     await fastify.register(etagRoutes);
-    await fastify.register(plainRoute);
     await fastify.register(responseHeadersRoutes);
   }
+  async registerResponseFormatRoutes(fastifyInstance) {
+    const fastify = fastifyInstance ?? this._server;
+    await fastify.register(responseFormatRoutes);
+  }
   /**
   * Register the redirect routes.
   * @param fastifyInstance - the server instance to register the routes on.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jaredwray/mockhttp",
-	"version": "0.8.0",
+	"version": "0.9.0",
 	"description": "Mock Http - Easy way to mock http with httpbin replacement",
 	"type": "module",
 	"main": "dist/index.js",