feat: test cases for fastify 5

RahulTinku · RahulTinku · commit 7713dc1f9e6e · 2025-09-25T13:41:21.000+05:30
diff --git a/README.md b/README.md
@@ -212,7 +212,6 @@ Configure electrode provided options.
 - A function to install event listeners for the electrode server startup lifecycle.
 
 - The following events are supported:
-
   - `config-composed` - All configurations have been composed into a single one
   - `server-created` - Fastify server created
   - `plugins-sorted` - Plugins processed and sorted by priority
@@ -450,11 +449,9 @@ The electrode server exports a single API.
 
 - `config` is the [electrode server config](#configuration-options)
 - `decors` - Optional extra `config` or array of `config`. In case you have common config you want to put inside a dedicated module, you can pass them in here.
-
   - If it's an array like `[ decor1, decor2, decor3 ]` then each one is composed into the main config. ie: something similar to `_.merge(mainConfig, decor1, decor2, decor3)`.
 
 - `callback` is an optional errback with the signature `function (err, server)`
-
   - where `server` is the Fastify server
 
 - **Returns:** a promise resolving to the Fastify server if callback is not provided
@@ -496,7 +493,7 @@ identity (no compression)
 
 ```js
 server: {
-  bodyLimit: 1048576 // new size limit in bytes (1MB)
+  bodyLimit: 1048576; // new size limit in bytes (1MB)
 }
 ```
 
diff --git a/package.json b/package.json
@@ -71,6 +71,7 @@
     "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
+    "@xarc/run": "^2.2.0",
     "eslint": "^7.16.0",
     "eslint-config-walmart": "^2.2.1",
     "eslint-plugin-filenames": "^1.1.0",
diff --git a/src/types.ts b/src/types.ts
@@ -208,7 +208,7 @@ export type ElectrodeServerConfig = {
    * - `requestIdHeader` now defaults to `false` instead of `"request-id"`
    * - Router options like `maxParamLength`, `ignoreTrailingSlash`, etc. should be
    *   moved under `routerOptions` to avoid deprecation warnings
-   * - Example: 
+   * - Example:
    * ```js
    * {
    *   server: {
diff --git a/test/spec/check-node-env.spec.ts b/test/spec/check-node-env.spec.ts
@@ -21,8 +21,18 @@ describe("process-env-abbr", function () {
     checkNodeEnv();
   });
 
+  it("should do nothing for undefined NODE_ENV", function () {
+    delete process.env.NODE_ENV;
+    checkNodeEnv();
+  });
+
+  it("should do nothing for null NODE_ENV", function () {
+    process.env.NODE_ENV = null as any;
+    checkNodeEnv();
+  });
+
   it("should do nothing for full NODE_ENV", function () {
-    ["production", "staging", "development"].forEach(x => {
+    ["production", "staging", "development", "qa", "test"].forEach(x => {
       process.env.NODE_ENV = x;
       checkNodeEnv();
     });
diff --git a/test/spec/fastify5-config.spec.ts b/test/spec/fastify5-config.spec.ts
@@ -0,0 +1,327 @@
+// Test to verify Fastify 5 configuration and plugin compatibility
+import { electrodeServer } from "../../src/electrode-server";
+import { ElectrodeFastifyInstance } from "../../src/types";
+
+describe("Fastify 5 Compatibility", () => {
+  let server: ElectrodeFastifyInstance | undefined;
+
+  afterEach(async () => {
+    if (server) {
+      await server.close();
+      server = undefined;
+    }
+  });
+
+  describe("Migration Verification", () => {
+    it("should use Fastify 5.x", async () => {
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0 // Use random port
+        },
+        plugins: {}
+      });
+
+      expect(server.version).toMatch(/^5\./);
+      expect(server.version).toBe("5.6.1");
+    });
+
+    it("should work with Fastify 5 plugin system", async () => {
+      const pluginCalled = jest.fn();
+
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        plugins: {
+          testPlugin: {
+            register: async fastify => {
+              pluginCalled();
+              fastify.get("/test-plugin", async () => {
+                return { message: "Plugin working with Fastify 5" };
+              });
+            }
+          }
+        }
+      });
+
+      await server.start();
+
+      expect(pluginCalled).toHaveBeenCalled();
+
+      const response = await server.inject({
+        method: "GET",
+        url: "/test-plugin"
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.body)).toEqual({
+        message: "Plugin working with Fastify 5"
+      });
+    });
+
+    it("should handle Node.js 20+ features", async () => {
+      // Verify we're running on Node 20+
+      const nodeVersion = process.version;
+      const majorVersion = parseInt(nodeVersion.split(".")[0].substring(1), 10);
+      expect(majorVersion).toBeGreaterThanOrEqual(20);
+
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        plugins: {}
+      });
+
+      // Test that the server starts and works properly
+      await server.start();
+      expect(server.info.port).toBeGreaterThan(0);
+    });
+
+    it("should maintain compatibility with existing decorator patterns", async () => {
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        plugins: {}
+      });
+
+      // Test that all the custom decorators still work
+      expect(server.app).toBeDefined();
+      expect(server.app.config).toBeDefined();
+      expect(server.info).toBeDefined();
+      expect(server.start).toBeDefined();
+      expect(typeof server.start).toBe("function");
+    });
+  });
+
+  describe("Configuration Compatibility", () => {
+    it("should handle all common FastifyServerOptions with Fastify 5", async () => {
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        server: {
+          // Test common Fastify server options that might have changed
+          logger: false,
+          disableRequestLogging: true,
+          bodyLimit: 1048576,
+          connectionTimeout: 0,
+          keepAliveTimeout: 72000,
+          forceCloseConnections: false,
+          requestIdHeader: false, // This changed default in Fastify 5
+          requestIdLogLabel: "reqId",
+          http2: false,
+          https: false,
+          maxRequestsPerSocket: 0,
+          requestTimeout: 0,
+          pluginTimeout: 10000,
+          trustProxy: false,
+          // Router options should be under routerOptions in newer versions
+          routerOptions: {
+            maxParamLength: 1000,
+            ignoreTrailingSlash: false,
+            ignoreDuplicateSlashes: false,
+            caseSensitive: true,
+            allowUnsafeRegex: false
+          }
+        }
+      });
+
+      expect(server.version).toMatch(/^5\./);
+      await server.start();
+      expect(server.info.port).toBeGreaterThan(0);
+    });
+
+    it("should handle logger configuration with Fastify 5", async () => {
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        server: {
+          logger: {
+            level: "warn",
+            serializers: {
+              req: false,
+              res: false
+            }
+          }
+        }
+      });
+
+      expect(server.version).toMatch(/^5\./);
+      await server.start();
+    });
+
+    it("should work with requestIdHeader set to false (Fastify 5 default)", async () => {
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        server: {
+          requestIdHeader: false // This is now the default in Fastify 5
+        }
+      });
+
+      await server.start();
+
+      const response = await server.inject({
+        method: "GET",
+        url: "/non-existent-route"
+      });
+
+      // Should not have a request-id header by default
+      expect(response.headers["request-id"]).toBeUndefined();
+    });
+
+    it("should still work with requestIdHeader enabled", async () => {
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        server: {
+          requestIdHeader: "x-request-id"
+        },
+        plugins: {
+          testRoute: {
+            register: async fastify => {
+              fastify.get("/test-req-id", async request => {
+                return { requestId: request.id };
+              });
+            }
+          }
+        }
+      });
+
+      await server.start();
+
+      const response = await server.inject({
+        method: "GET",
+        url: "/test-req-id"
+      });
+
+      // Check that the request ID was generated and returned
+      const body = JSON.parse(response.body);
+      expect(body.requestId).toBeDefined();
+      expect(typeof body.requestId).toBe("string");
+    });
+
+    it("should handle new Fastify 5 options if any", async () => {
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        server: {
+          // Any new Fastify 5 specific options would go here
+          // Currently testing that it doesn't break with standard options
+          jsonShorthand: true,
+          ajv: {
+            customOptions: {
+              coerceTypes: "array"
+            }
+          }
+        }
+      });
+
+      expect(server.version).toMatch(/^5\./);
+      await server.start();
+    });
+  });
+
+  describe("Plugin Registration Compatibility", () => {
+    it("should handle plugin registration with .after() pattern in Fastify 5", async () => {
+      let pluginExecuted = false;
+      let afterExecuted = false;
+
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        plugins: {
+          testPlugin: {
+            register: async fastify => {
+              pluginExecuted = true;
+
+              // Add a simple route to verify the plugin works
+              fastify.get("/test-after", async () => {
+                return { message: "Plugin with .after() works in Fastify 5" };
+              });
+
+              // Test that we can use .after() functionality
+              fastify.after(() => {
+                afterExecuted = true;
+              });
+            },
+            options: {}
+          }
+        }
+      });
+
+      expect(pluginExecuted).toBe(true);
+
+      await server.start();
+
+      // Test the route works
+      const response = await server.inject({
+        method: "GET",
+        url: "/test-after"
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.body)).toEqual({
+        message: "Plugin with .after() works in Fastify 5"
+      });
+
+      // Verify .after() was called
+      expect(afterExecuted).toBe(true);
+    });
+
+    it("should handle multiple plugins with .after() callbacks", async () => {
+      const pluginOrder: string[] = [];
+
+      server = await electrodeServer({
+        deferStart: true,
+        connection: {
+          port: 0
+        },
+        plugins: {
+          firstPlugin: {
+            priority: 1,
+            register: async fastify => {
+              pluginOrder.push("first-register");
+              fastify.after(() => {
+                pluginOrder.push("first-after");
+              });
+            }
+          },
+          secondPlugin: {
+            priority: 2,
+            register: async fastify => {
+              pluginOrder.push("second-register");
+              fastify.after(() => {
+                pluginOrder.push("second-after");
+              });
+            }
+          }
+        }
+      });
+
+      await server.start();
+
+      // Verify the execution order
+      expect(pluginOrder).toContain("first-register");
+      expect(pluginOrder).toContain("second-register");
+      expect(pluginOrder).toContain("first-after");
+      expect(pluginOrder).toContain("second-after");
+    });
+  });
+});
