@tpzdsp/next-toolkit 1.14.2 → 1.15.0

package/src/http/logger.test.ts

@@ -0,0 +1,346 @@
+import { Header, HttpMethod, MimeType } from './constants';
+import { requestLogger } from './logger';
+
+type MockRequest = {
+  method: string;
+  url: string;
+  body?: unknown;
+  headers: Headers;
+  meta?: {
+    requestId: string;
+  };
+  retryAttempt?: number;
+  loggerOverrides?: {
+    requestFormat?: (args: { request: MockRequest }) => string;
+    successFormat?: (args: {
+      request: MockRequest;
+      response: Response;
+      data: unknown;
+      durationMs: number;
+    }) => string;
+    errorFormat?: (args: {
+      request: MockRequest;
+      response?: Response;
+      error: unknown;
+      durationMs: number;
+    }) => string;
+    retryFormat?: (args: { request: MockRequest; attempt: number }) => string;
+  };
+};
+
+const createRequest = (overrides: Partial<MockRequest> = {}): MockRequest => ({
+  method: HttpMethod.Post,
+  url: 'https://api.example.com/users',
+  body: { name: 'Alice' },
+  headers: new Headers({
+    [Header.ContentType]: MimeType.Json,
+    [Header.Accept]: MimeType.Json,
+  }),
+  ...overrides,
+});
+
+const createResponse = (overrides: Partial<Response> = {}): Response =>
+  ({
+    status: 200,
+    headers: new Headers({
+      [Header.ContentType]: MimeType.Json,
+    }),
+    ...overrides,
+  }) as Response;
+
+describe('requestLogger', () => {
+  const nowSpy = vi.spyOn(performance, 'now');
+  const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+  const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+  const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    nowSpy.mockReset();
+    nowSpy.mockReturnValue(25.0);
+
+    vi.stubGlobal('crypto', {
+      randomUUID: vi.fn(() => 'abc12345-def6-7890-abcd-ef1234567890'),
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('logs the default request message and sets the request id header', async () => {
+    const plugin = requestLogger();
+    const request = createRequest();
+
+    await plugin?.hooks?.onRequest?.(request as never);
+
+    expect(request.meta?.requestId).toBe('ABC12345');
+    expect(request.headers.get(Header.XRequestId)).toBe('ABC12345');
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+
+    const message = consoleLogSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain('🚀 [POST] (ABC12345) https://api.example.com/users');
+    expect(message).toContain('\t↳ Req. Content-Type: application/json');
+    expect(message).toContain('\t↳ Req. Accept: application/json');
+    expect(message).toContain('\t↳ Req. Body: {"name":"Alice"}');
+  });
+
+  it('logs the default success message', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      meta: { requestId: 'ABC12345' },
+    });
+
+    await plugin?.hooks?.onSuccess?.({
+      request,
+      response: createResponse({ status: 201 }),
+      data: { id: 1, name: 'Alice' },
+    } as never);
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+
+    const message = consoleLogSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain('✅ [POST] (ABC12345) https://api.example.com/users');
+    expect(message).toContain('\t↳ 201 | 25.0ms');
+    expect(message).toContain('\t↳ Res. Content-Type: application/json');
+    expect(message).toContain('\t↳ Res. Body: {"id":1,"name":"Alice"}');
+  });
+
+  it('logs the default retry message', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      meta: { requestId: 'ABC12345' },
+      retryAttempt: 1,
+    });
+
+    await plugin?.hooks?.onRetry?.({
+      request,
+    } as never);
+
+    expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+
+    const message = consoleWarnSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain('🔁 [POST] (ABC12345) https://api.example.com/users Retrying...');
+    expect(message).toContain('\t↳ Attempt: 2');
+  });
+
+  it('logs the default error message', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      meta: { requestId: 'ABC12345' },
+    });
+
+    await plugin?.hooks?.onError?.({
+      request,
+      response: createResponse({ status: 500 }),
+      error: { message: 'boom' },
+    } as never);
+
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+
+    const message = consoleErrorSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain('❌ [POST] (ABC12345) https://api.example.com/users');
+    expect(message).toContain('\t↳ 500 | 25.0ms');
+    expect(message).toContain('\t↳ Error: {"message":"boom"}');
+  });
+
+  it('respects grouped show options', async () => {
+    const plugin = requestLogger({
+      showMethod: false,
+      showUrl: false,
+      showAcceptHeader: false,
+      showContentType: false,
+      showBody: { request: false, response: true },
+      showHeaders: { request: true, response: false },
+    });
+
+    const request = createRequest();
+
+    await plugin?.hooks?.onRequest?.(request as never);
+
+    const message = consoleLogSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain('🚀 (ABC12345)');
+    expect(message).toContain('\t↳ Req. Headers:');
+    expect(message).not.toContain('[POST]');
+    expect(message).not.toContain('https://api.example.com/users');
+    expect(message).not.toContain('Req. Accept');
+    expect(message).not.toContain('Req. Content-Type');
+    expect(message).not.toContain('Req. Body');
+  });
+
+  it('prints the full body on a new line when truncateBody is false', async () => {
+    const plugin = requestLogger({
+      truncateBody: false,
+    });
+
+    const request = createRequest({
+      body: {
+        very: 'long',
+        nested: {
+          value: 'hello',
+        },
+      },
+    });
+
+    await plugin?.hooks?.onRequest?.(request as never);
+
+    const message = consoleLogSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain('\t↳ Req. Body:\n{"very":"long","nested":{"value":"hello"}}');
+  });
+
+  it('truncates long bodies by default', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      body: 'x'.repeat(200),
+    });
+
+    await plugin?.hooks?.onRequest?.(request as never);
+
+    const message = consoleLogSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain(`\t↳ Req. Body: ${'x'.repeat(150)}…`);
+  });
+
+  it('uses the request format override when provided', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      loggerOverrides: {
+        requestFormat: ({ request: req }) => `custom request log for ${req.url}`,
+      },
+    });
+
+    await plugin?.hooks?.onRequest?.(request as never);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      'custom request log for https://api.example.com/users\n',
+    );
+  });
+
+  it('uses the success format override when provided', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      meta: { requestId: 'ABC12345' },
+      loggerOverrides: {
+        successFormat: ({ response, durationMs }) =>
+          `custom success ${response.status} ${durationMs.toFixed(1)}`,
+      },
+    });
+
+    await plugin?.hooks?.onSuccess?.({
+      request,
+      response: createResponse({ status: 204 }),
+      data: null,
+    } as never);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith('custom success 204 25.0\n');
+  });
+
+  it('uses the retry format override when provided', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      meta: { requestId: 'ABC12345' },
+      retryAttempt: 2,
+      loggerOverrides: {
+        retryFormat: ({ attempt }) => `custom retry ${attempt}`,
+      },
+    });
+
+    await plugin?.hooks?.onRetry?.({
+      request,
+    } as never);
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith('custom retry 3\n');
+  });
+
+  it('uses the error format override when provided', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      meta: { requestId: 'ABC12345' },
+      loggerOverrides: {
+        errorFormat: ({ durationMs }) => `custom error ${durationMs.toFixed(1)}`,
+      },
+    });
+
+    await plugin?.hooks?.onError?.({
+      request,
+      response: createResponse({ status: 400 }),
+      error: new Error('nope'),
+    } as never);
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith('custom error 25.0\n');
+  });
+
+  it('does not log when disabled is false', async () => {
+    const plugin = requestLogger({
+      enabled: false,
+    });
+
+    await plugin?.hooks?.onRequest?.(createRequest() as never);
+    await plugin?.hooks?.onSuccess?.({
+      request: createRequest({
+        meta: { requestId: 'ABC12345' },
+      }),
+      response: createResponse(),
+      data: {},
+    } as never);
+    await plugin?.hooks?.onRetry?.({
+      request: createRequest({
+        meta: { requestId: 'ABC12345' },
+      }),
+    } as never);
+    await plugin?.hooks?.onError?.({
+      request: createRequest({
+        meta: { requestId: 'ABC12345' },
+      }),
+      error: new Error('boom'),
+    } as never);
+
+    expect(consoleLogSpy).not.toHaveBeenCalled();
+    expect(consoleWarnSpy).not.toHaveBeenCalled();
+    expect(consoleErrorSpy).not.toHaveBeenCalled();
+  });
+
+  it('supports enabled as an async function', async () => {
+    const plugin = requestLogger({
+      enabled: vi.fn(async () => true),
+    });
+
+    await plugin?.hooks?.onRequest?.(createRequest() as never);
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('uses unknown as the fallback status in error logs when there is no response', async () => {
+    const plugin = requestLogger();
+
+    const request = createRequest({
+      meta: { requestId: 'ABC12345' },
+    });
+
+    await plugin?.hooks?.onError?.({
+      request,
+      error: { message: 'network failed' },
+    } as never);
+
+    const message = consoleErrorSpy.mock.calls[0]?.[0];
+
+    expect(message).toContain('\t↳ unknown | 25.0ms');
+    expect(message).toContain('\t↳ Error: {"message":"network failed"}');
+  });
+});