Add more tests

Author: patrickrizzardi

README.md

@@ -183,6 +183,64 @@ app.listen();
 console.log('Server running on http://localhost:3000');
 ```
 
+#### ConnectionManager API
+
+The `ConnectionManager` class provides the following methods and properties:
+
+- **Methods**:
+  - `setServer(server: Server)`: Associates the connection manager with a server instance
+  - `addConnection(socket: Socket)`: Registers a new socket connection for tracking
+  - `removeConnection(socket: Socket)`: Removes a socket from tracking when it closes
+  - `getStats()`: Returns statistics about connections (`IConnectionStats`)
+  - `closeAllConnections(gracePeriod?: number)`: Gracefully closes all active connections
+  - `on(event: ConnectionEvent, listener: Function)`: Subscribes to connection events
+  - `off(event: ConnectionEvent, listener: Function)`: Unsubscribes from connection events
+
+- **Events**:
+  - `CONNECTION_ADDED`: Fired when a new connection is established
+  - `CONNECTION_REMOVED`: Fired when a connection is closed
+  - `CONNECTION_ERROR`: Fired when a connection encounters an error
+  - `ALL_CONNECTIONS_CLOSED`: Fired when all connections have been closed
+  - `SERVER_LISTENING`: Fired when the server starts listening
+  - `SERVER_CLOSED`: Fired when the server is closed
+
+- **Statistics**:
+  - `activeConnections`: Number of currently active connections
+  - `totalConnections`: Total number of connections since server start
+  - `connectionErrors`: Number of connection errors encountered
+  - `uptime`: Server uptime in milliseconds
+
+#### Graceful Shutdown Pattern
+
+For production applications, implementing a graceful shutdown pattern is recommended:
+
+```typescript
+// Graceful shutdown handler
+const gracefulShutdown = async (signal: string) => {
+  console.log(`${signal} received, starting graceful shutdown`);
+  
+  // Step 1: Stop accepting new connections (optional)
+  server.close();
+  
+  // Step 2: Allow existing connections to finish (with timeout)
+  console.log('Closing remaining connections...');
+  await app.connectionManager.closeAllConnections(10000); // 10 second grace period
+  
+  // Step 3: Close the server completely
+  console.log('Shutting down server...');
+  await app.close();
+  
+  console.log('Shutdown complete');
+  process.exit(0);
+};
+
+// Register shutdown handlers
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+```
+
+This pattern ensures that your server can handle restarts and deployments without dropping active connections.
+
 ## Examples
 
 Check out the [examples](/example) directory for more detailed usage examples:
@@ -199,6 +257,7 @@ For detailed documentation, see the [docs](/docs) directory:
 - [Request Lifecycle Hooks](/docs/hooks.md) - In-depth documentation of the hooks system
 - [Content Type Handling](/docs/content-types.md) - Working with different content types
 - [Error Handling](/docs/error-handling.md) - Guide to handling errors at different levels
+- [Testing Guide](/TESTING.md) - Comprehensive guide to testing the framework
 
 ## Project Structure
 
@@ -210,6 +269,7 @@ yinzerflow/
 │   ├── javascript/     # JavaScript example
 │   └── typescript/     # TypeScript example
 ├── package.json        # Package configuration
+├── TESTING.md          # Testing documentation
 └── README.md           # This file
 ```
 

app/core/__mocks__/Context.spec.ts

@@ -0,0 +1,22 @@
+import { mock } from 'bun:test';
+import type { Context } from '../Context.ts';
+
+/**
+ * Creates a mock Context object for testing
+ *
+ * @returns A mock Context object
+ */
+export const createMockContext = (): Context =>
+  ({
+    request: {
+      method: 'GET',
+      path: '/test',
+      params: {},
+      query: {},
+      headers: {},
+      body: null,
+    },
+    response: {
+      setStatus: mock(() => {}),
+    },
+  }) as unknown as Context;

app/core/__mocks__/Hook.spec.ts

@@ -0,0 +1,35 @@
+import { mock } from 'bun:test';
+import type { TUndefinableResponseFunction } from '../../types/Route.ts';
+
+type MockHook = TUndefinableResponseFunction & { mockClear: () => void };
+
+/**
+ * Creates a mock hook function that returns undefined (doesn't interrupt the request flow)
+ *
+ * @returns A mock hook function with mock methods
+ */
+export const createPassthroughHook = (): MockHook => {
+  return mock(() => undefined) as MockHook;
+};
+
+/**
+ * Creates a mock hook function that returns a response (interrupts the request flow)
+ *
+ * @param message - The message to return in the response
+ * @returns A mock hook function with mock methods
+ */
+export const createInterruptingHook = (message = 'Interrupted'): MockHook => {
+  return mock(() => ({ message })) as MockHook;
+};
+
+/**
+ * Creates a mock hook function that throws an error
+ *
+ * @param errorMessage - The error message
+ * @returns A mock hook function with mock methods
+ */
+export const createErrorHook = (errorMessage = 'Hook error'): MockHook => {
+  return mock(() => {
+    throw new Error(errorMessage);
+  }) as MockHook;
+};

app/core/__mocks__/Request.spec.ts

@@ -1,52 +1,56 @@
 import { HttpMethod } from '../../constants/http.ts';
-import type { IHeaders } from '../../types/http/Response.ts';
-import type { IRequest, THttpMethod, TRequestBody } from '../../types/http/Request.ts';
+import type { Request } from '../Request.ts';
 
 /**
- * A mock implementation of the Request class for testing
+ * Creates a mock Request object for testing
+ *
+ * @param method - HTTP method
+ * @param path - Request path
+ * @returns A mock Request object
  */
-export class MockRequest implements Partial<IRequest> {
-  protocol: string;
-  method: THttpMethod;
+export const createMockRequest = (method: string = HttpMethod.GET, path = '/test'): Request =>
+  ({
+    method,
+    path,
+    params: {},
+    query: {},
+    headers: {},
+    body: null,
+  }) as unknown as Request;
+
+/**
+ * Mock Request class for testing Response
+ */
+export class MockRequest {
+  method: string;
   path: string;
-  headers: IHeaders;
-  body: TRequestBody;
-  query: Record<string, string>;
+  headers: Record<string, string>;
+  body: any;
   params: Record<string, string>;
+  query: Record<string, string>;
+  protocol: string;
 
-  constructor({ protocol = 'HTTP/1.1', method = HttpMethod.GET, path = '/', headers = {}, body = {}, query = {}, params = {} }: Partial<IRequest> = {}) {
-    this.protocol = protocol;
-    this.method = method;
-    this.path = path;
-    this.headers = headers;
-    this.body = body;
-    this.query = query as Record<string, string>;
-    this.params = params as Record<string, string>;
+  constructor(
+    options: {
+      method?: string;
+      path?: string;
+      headers?: Record<string, string>;
+      body?: any;
+      params?: Record<string, string>;
+      query?: Record<string, string>;
+      protocol?: string;
+    } = {},
+  ) {
+    this.method = options.method ?? HttpMethod.GET;
+    this.path = options.path ?? '/';
+    this.headers = options.headers ?? {};
+    this.body = options.body ?? null;
+    this.params = options.params ?? {};
+    this.query = options.query ?? {};
+    this.protocol = options.protocol ?? 'HTTP/1.1';
   }
 
-  /**
-   * Creates a default mock request
-   */
   static createDefault(): MockRequest {
     return new MockRequest();
   }
-
-  /**
-   * Creates a mock GET request
-   */
-  static createGet(path = '/', query = {}): MockRequest {
-    return new MockRequest({ method: HttpMethod.GET, path, query });
-  }
-
-  /**
-   * Creates a mock POST request
-   */
-  static createPost(path = '/', body = {}): MockRequest {
-    return new MockRequest({
-      method: HttpMethod.POST,
-      path,
-      body,
-      headers: { 'Content-Type': 'application/json' } as IHeaders,
-    });
-  }
 }

app/core/__mocks__/Route.spec.ts

@@ -0,0 +1,13 @@
+import type { IRoute } from '../../types/Route.ts';
+
+/**
+ * Creates a mock Route object for testing
+ *
+ * @param path - The route path
+ * @returns A mock IRoute object
+ */
+export const createMockRoute = (path: string): IRoute => ({
+  method: 'GET',
+  path,
+  handler: () => ({}),
+});

app/core/__mocks__/RouteHandler.spec.ts

@@ -0,0 +1,11 @@
+import type { TResponseFunction } from '../../types/Route.ts';
+
+/**
+ * Creates a mock route handler that returns a simple message
+ *
+ * @param message - The message to return
+ * @returns A mock route handler function
+ */
+export const createMockHandler = (message = 'Hello'): TResponseFunction => {
+  return () => ({ message });
+};