WIP fix tests on windows

Author: Ndpnt

src/archivist/recorder/index.test.js

@@ -10,11 +10,11 @@ const MIME_TYPE = 'text/html';
 const FETCH_DATE = new Date('2000-01-01T12:00:00.000Z');
 const FETCH_DATE_LATER = new Date('2000-01-02T12:00:00.000Z');
 
-describe('Recorder', () => {
+describe.only('Recorder', () => {
   const SERVICE_ID = 'test_service';
   const TYPE = 'Terms of Service';
 
-  for (const repositoryType of [ 'git', 'mongo' ]) {
+  for (const repositoryType of ['mongo']) {
     describe(repositoryType, () => {
       let recorder;
 

src/archivist/recorder/repositories/mongo/index.js

@@ -10,16 +10,46 @@ import RepositoryInterface from '../interface.js';
 import * as DataMapper from './dataMapper.js';
 
 export default class MongoRepository extends RepositoryInterface {
+  /**
+   * Shared MongoClient management with reference counting.
+   *
+   * Multiple repositories connecting to the same MongoDB server/database share a single MongoClient instance
+   * to avoid race conditions during cleanup. Without sharing, each repository would create its own client,
+   * and closing them sequentially could still cause "Operation interrupted because client was closed" errors.
+   * This issue has been observed on Windows but not on Linux or macOS, suggesting platform-specific differences
+   * in how connection pool cleanup is handled.
+   *
+   * The reference counting ensures that the shared client is only closed when the last repository using it
+   * calls finalize(), preventing premature connection closure while operations are still in progress.
+   */
+  static #clients = new Map(); // connectionURI -> MongoClient
+  static #refCounts = new Map(); // connectionURI -> number of repositories using this client
+
   constructor({ database: databaseName, collection: collectionName, connectionURI }) {
     super();
 
-    this.client = new MongoClient(connectionURI);
+    this.connectionURI = connectionURI;
     this.databaseName = databaseName;
     this.collectionName = collectionName;
+    this.client = null;
   }
 
   async initialize() {
-    await this.client.connect();
+    console.log('MongoRepository.#clients', MongoRepository.#clients);
+    if (MongoRepository.#clients.has(this.connectionURI)) {
+      console.log('reuse client');
+      // Reuse existing client
+      this.client = MongoRepository.#clients.get(this.connectionURI);
+      MongoRepository.#refCounts.set(this.connectionURI, MongoRepository.#refCounts.get(this.connectionURI) + 1);
+    } else {
+      // Create new client
+      console.log('create new client');
+      this.client = new MongoClient(this.connectionURI);
+      await this.client.connect();
+      MongoRepository.#clients.set(this.connectionURI, this.client);
+      MongoRepository.#refCounts.set(this.connectionURI, 1);
+    }
+
     const db = this.client.db(this.databaseName);
 
     this.collection = db.collection(this.collectionName);
@@ -29,8 +59,18 @@ export default class MongoRepository extends RepositoryInterface {
     return this;
   }
 
-  finalize() {
-    return this.client.close();
+  async finalize() {
+    const refCount = MongoRepository.#refCounts.get(this.connectionURI);
+
+    if (refCount === 1) {
+      // Last repository using this client - close it
+      await this.client.close();
+      MongoRepository.#clients.delete(this.connectionURI);
+      MongoRepository.#refCounts.delete(this.connectionURI);
+    } else {
+      // Other repositories still using this client - just decrement
+      MongoRepository.#refCounts.set(this.connectionURI, refCount - 1);
+    }
   }
 
   async save(record) {
@@ -108,7 +148,7 @@ export default class MongoRepository extends RepositoryInterface {
   }
 
   removeAll() {
-    return this.collection.deleteMany();
+    return this.collection.deleteMany({});
   }
 
   async loadRecordContent(record) {