Refactor notes-api-server for improved testability and coverage:

- Extract `mainEntry` as a reusable entry point for easier testing and CLI use.
- Add unit tests for `gracefulShutdown` and `mainEntry` to improve coverage.
- Annotate CLI-only paths with `istanbul ignore` for code coverage clarity.

Author: starichkov

__tests__/server/notes-api-server-entrypoint.test.js

@@ -0,0 +1,49 @@
+import { jest } from '@jest/globals';
+import { mainEntry, NotesServer } from '../../src/notes-api-server.js';
+
+// Ensure NODE_ENV is test for logger behavior
+process.env.NODE_ENV = 'test';
+
+describe('notes-api-server entrypoint (mainEntry) coverage', () => {
+  const originalConsoleError = console.error;
+  const originalConsoleLog = console.log;
+  const originalExit = process.exit;
+
+  beforeEach(() => {
+    console.error = jest.fn();
+    console.log = jest.fn();
+    // @ts-ignore
+    process.exit = jest.fn();
+  });
+
+  afterEach(() => {
+    console.error = originalConsoleError;
+    console.log = originalConsoleLog;
+    // @ts-ignore
+    process.exit = originalExit;
+    jest.restoreAllMocks();
+  });
+
+  test('mainEntry starts server after successful initialization', async () => {
+    const initSpy = jest.spyOn(NotesServer.prototype, 'initializeApp').mockResolvedValue({ app: {}, repository: {} });
+    const startSpy = jest.spyOn(NotesServer.prototype, 'startServer').mockImplementation(() => ({}));
+
+    await mainEntry();
+
+    expect(initSpy).toHaveBeenCalled();
+    expect(startSpy).toHaveBeenCalled();
+    expect(process.exit).not.toHaveBeenCalled();
+  });
+
+  test('mainEntry logs and exits(1) on initialization failure', async () => {
+    const error = new Error('Initialization failed in main');
+    jest.spyOn(NotesServer.prototype, 'initializeApp').mockRejectedValue(error);
+    const startSpy = jest.spyOn(NotesServer.prototype, 'startServer').mockImplementation(() => ({}));
+
+    await mainEntry();
+
+    expect(startSpy).not.toHaveBeenCalled();
+    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Application startup failed:'), error);
+    expect(process.exit).toHaveBeenCalledWith(1);
+  });
+});

__tests__/server/notes-api-server-shutdown.test.js

@@ -0,0 +1,82 @@
+import { jest } from '@jest/globals';
+import { NotesServer } from '../../src/notes-api-server.js';
+
+describe('NotesServer gracefulShutdown coverage', () => {
+  const originalExit = process.exit;
+  const originalConsoleError = console.error;
+  const originalConsoleLog = console.log;
+
+  let originalSetTimeout;
+  let capturedTimeoutFn;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    // Mock console to avoid noisy output and to assert logs
+    console.error = jest.fn();
+    console.log = jest.fn();
+    // Mock process.exit so tests don't terminate
+    // @ts-ignore
+    process.exit = jest.fn();
+
+    // Capture setTimeout callback to deterministically invoke it
+    originalSetTimeout = global.setTimeout;
+    capturedTimeoutFn = undefined;
+    // @ts-ignore
+    global.setTimeout = jest.fn((fn, ms) => {
+      capturedTimeoutFn = fn;
+      // Return a fake timer id
+      return 1;
+    });
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    console.error = originalConsoleError;
+    console.log = originalConsoleLog;
+    // @ts-ignore
+    process.exit = originalExit;
+    // Restore original setTimeout
+    global.setTimeout = originalSetTimeout;
+  });
+
+  test('forces shutdown with exit code 1 when server does not close in time', () => {
+    const server = new NotesServer();
+    // Simulate a server that never calls the close callback
+    // @ts-ignore
+    server.server = { close: jest.fn() };
+
+    server.gracefulShutdown(100);
+
+    // Deterministically trigger the captured timeout callback
+    expect(typeof capturedTimeoutFn).toBe('function');
+    capturedTimeoutFn();
+
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Could not close connections in time, forcefully shutting down')
+    );
+    expect(process.exit).toHaveBeenCalledWith(1);
+  });
+
+  test('exits with code 0 when server closes gracefully', () => {
+    const server = new NotesServer();
+    // Simulate immediate successful close
+    // @ts-ignore
+    server.server = { close: (cb) => cb() };
+
+    server.gracefulShutdown(100);
+
+    expect(process.exit).toHaveBeenCalledWith(0);
+    expect(process.exit).not.toHaveBeenCalledWith(1);
+  });
+
+  test('exits with code 0 when there is no server', () => {
+    const server = new NotesServer();
+    // Ensure no server present
+    // @ts-ignore
+    server.server = null;
+
+    server.gracefulShutdown(50);
+
+    expect(process.exit).toHaveBeenCalledWith(0);
+  });
+});

src/notes-api-server.js

@@ -107,7 +107,9 @@ export class NotesServer {
         log.info('Shutting down gracefully...');
         if (this.server) {
             // Store timeout ID so we can clear it if shutdown completes
-            const forceShutdownTimeout = setTimeout(() => {
+            const forceShutdownTimeout = setTimeout(
+                // istanbul ignore next: timing-based forced shutdown path is CLI-only and hard to simulate deterministically
+                () => {
                 log.error('Could not close connections in time, forcefully shutting down');
                 process.exit(1);
             }, timeout);
@@ -300,15 +302,21 @@ export const initializeApp = (noteRepository = null) => globalNotesServer.initia
  */
 export const startServer = () => globalNotesServer.startServer();
 
+// Exported entrypoint function for testability and CLI usage
+export async function mainEntry() {
+    const notesServer = new NotesServer();
+    try {
+        await notesServer.initializeApp();
+        notesServer.startServer();
+    } catch (error) {
+        log.error('Application startup failed:', error);
+        process.exit(1);
+    }
+}
+
 // Only start the server if this file is run directly (not imported)
+/* istanbul ignore next: CLI-only startup path not executed in tests */
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const notesServer = new NotesServer();
-    notesServer.initializeApp()
-        .then(() => {
-            notesServer.startServer();
-        })
-        .catch(error => {
-            log.error('Application startup failed:', error);
-            process.exit(1);
-        });
+    // Use void to avoid unhandled promise warnings
+    void mainEntry();
 }