test: remove usage of "tmp" package

Author: hasezoey

packages/mongodb-memory-server-core/src/__tests__/MongoMemoryReplSet-restart.test.ts

@@ -1,14 +1,13 @@
 import MongoMemoryReplSet, { MongoMemoryReplSetOpts } from '../MongoMemoryReplSet';
-import * as tmp from 'tmp';
+import { createTmpDir, removeDir } from '../util/utils';
 
-tmp.setGracefulCleanup();
-let tmpDir: tmp.DirResult;
-beforeEach(() => {
-  tmpDir = tmp.dirSync({ prefix: 'reuse-mongo-mem-', unsafeCleanup: true });
+let tmpDir: string;
+beforeEach(async () => {
+  tmpDir = await createTmpDir('reuse-mongo-mem-');
 });
 
-afterEach(() => {
-  tmpDir.removeCallback();
+afterEach(async () => {
+  await removeDir(tmpDir);
 });
 
 const sleep = (ms: number) => {
@@ -24,7 +23,7 @@ describe('Restart single MongoMemoryReplSet instance', () => {
       instanceOpts: [
         {
           port: 27017,
-          dbPath: tmpDir.name,
+          dbPath: tmpDir,
         },
       ],
     } as MongoMemoryReplSetOpts;

packages/mongodb-memory-server-core/src/__tests__/MongoMemoryServer.test.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { MongoClient, MongoServerError } from 'mongodb';
-import * as tmp from 'tmp';
 import MongoMemoryServer, {
   CreateUser,
   MongoInstanceData,
@@ -15,7 +14,6 @@ import { assertIsError } from './testUtils/test_utils';
 import { promises as fspromises } from 'fs';
 import * as path from 'path';
 
-tmp.setGracefulCleanup();
 jest.setTimeout(100000); // 10s
 
 afterEach(() => {
@@ -770,7 +768,7 @@ describe('MongoMemoryServer', () => {
 
   describe('cleanup()', () => {
     /** Cleanup the created tmp-dir, even if the cleanup test tested to not clean it up */
-    let tmpdir: tmp.DirResult | undefined;
+    let tmpdir: string | undefined;
 
     // "beforeAll" dosnt work here, thanks to the top-level "afterAll" hook
     beforeEach(() => {
@@ -779,9 +777,9 @@ describe('MongoMemoryServer', () => {
       jest.spyOn(semver.default, 'lt'); // it needs to be ".default" otherwise "lt" is only an getter
     });
 
-    afterEach(() => {
+    afterEach(async () => {
       if (!utils.isNullOrUndefined(tmpdir)) {
-        tmpdir.removeCallback();
+        await utils.removeDir(tmpdir);
 
         tmpdir = undefined; // reset, just to be sure its clean
       }
@@ -820,8 +818,8 @@ describe('MongoMemoryServer', () => {
     });
 
     it('should properly cleanup with force (without tmpDir) (old)', async () => {
-      const tmpDir = tmp.dirSync({ prefix: 'mongo-mem-cleanup-', unsafeCleanup: true });
-      const mongoServer = await MongoMemoryServer.create({ instance: { dbPath: tmpDir.name } });
+      const tmpDir = await utils.createTmpDir('mongo-mem-cleanup-');
+      const mongoServer = await MongoMemoryServer.create({ instance: { dbPath: tmpDir } });
       const dbPath = mongoServer.instanceInfo!.dbPath;
 
       tmpdir = mongoServer.instanceInfo?.tmpDir;
@@ -873,8 +871,8 @@ describe('MongoMemoryServer', () => {
     });
 
     it('should properly cleanup with force (without tmpDir) (new)', async () => {
-      const tmpDir = tmp.dirSync({ prefix: 'mongo-mem-cleanup-', unsafeCleanup: true });
-      const mongoServer = await MongoMemoryServer.create({ instance: { dbPath: tmpDir.name } });
+      const tmpDir = await utils.createTmpDir('mongo-mem-cleanup-');
+      const mongoServer = await MongoMemoryServer.create({ instance: { dbPath: tmpDir } });
       const dbPath = mongoServer.instanceInfo!.dbPath;
 
       const cleanupSpy = jest.spyOn(mongoServer, 'cleanup');
@@ -926,10 +924,10 @@ describe('MongoMemoryServer', () => {
 
     it('should resolve "isNew" to "true" and set "createAuth" to "true" when dbPath is set, but empty', async () => {
       const readdirSpy = jest.spyOn(fspromises, 'readdir');
-      const tmpDbPath = tmp.dirSync({ prefix: 'mongo-mem-getStartOptions1-', unsafeCleanup: true });
+      const tmpDbPath = await utils.createTmpDir('mongo-mem-getStartOptions1-');
 
       const mongoServer = new MongoMemoryServer({
-        instance: { dbPath: tmpDbPath.name },
+        instance: { dbPath: tmpDbPath },
         auth: {},
       });
 
@@ -942,22 +940,22 @@ describe('MongoMemoryServer', () => {
         new Error('Expected "options.data.dbPath" to be defined')
       );
       expect(await utils.pathExists(options.data.dbPath)).toEqual(true);
-      expect(options.data.dbPath).toEqual(tmpDbPath.name);
+      expect(options.data.dbPath).toEqual(tmpDbPath);
       expect(readdirSpy).toHaveBeenCalledTimes(1);
       expect(options.createAuth).toEqual(true);
 
-      tmpDbPath.removeCallback();
+      await utils.removeDir(tmpDbPath);
     });
 
     it('should resolve "isNew" to "false" and set "createAuth" to "false" when dbPath is set, but not empty', async () => {
       const readdirSpy = jest.spyOn(fspromises, 'readdir');
-      const tmpDbPath = tmp.dirSync({ prefix: 'mongo-mem-getStartOptions1-', unsafeCleanup: true });
+      const tmpDbPath = await utils.createTmpDir('mongo-mem-getStartOptions2-');
 
       // create dummy file, to make the directory non-empty
-      await fspromises.writeFile(path.resolve(tmpDbPath.name, 'testfile'), '');
+      await fspromises.writeFile(path.resolve(tmpDbPath, 'testfile'), '');
 
       const mongoServer = new MongoMemoryServer({
-        instance: { dbPath: tmpDbPath.name },
+        instance: { dbPath: tmpDbPath },
         auth: {},
       });
 
@@ -970,11 +968,11 @@ describe('MongoMemoryServer', () => {
         new Error('Expected "options.data.dbPath" to be defined')
       );
       expect(await utils.pathExists(options.data.dbPath)).toEqual(true);
-      expect(options.data.dbPath).toEqual(tmpDbPath.name);
+      expect(options.data.dbPath).toEqual(tmpDbPath);
       expect(readdirSpy).toHaveBeenCalledTimes(1);
       expect(options.createAuth).toEqual(false);
 
-      tmpDbPath.removeCallback();
+      await utils.removeDir(tmpDbPath);
     });
 
     it('should generate a port when no suggestion is defined', async () => {
@@ -1027,17 +1025,17 @@ describe('MongoMemoryServer', () => {
   });
 
   it('"getDbPath" should return the dbPath', async () => {
-    const tmpDir = tmp.dirSync({ prefix: 'mongo-mem-getDbPath-', unsafeCleanup: true });
+    const tmpDir = await utils.createTmpDir('mongo-mem-getDbPath-');
     const mongoServer = new MongoMemoryServer({
-      instance: { dbPath: tmpDir.name },
+      instance: { dbPath: tmpDir },
     });
 
     await mongoServer.start();
 
-    expect(mongoServer.instanceInfo!.dbPath).toEqual(tmpDir.name);
+    expect(mongoServer.instanceInfo!.dbPath).toEqual(tmpDir);
 
     await mongoServer.stop();
-    tmpDir.removeCallback();
+    await utils.removeDir(tmpDir);
   });
 
   it('"state" should return correct state', () => {

packages/mongodb-memory-server-core/src/util/__tests__/MongoBinary.test.ts

@@ -1,4 +1,3 @@
-import * as tmp from 'tmp';
 import os from 'os';
 import MongoBinary, { MongoBinaryOpts } from '../MongoBinary';
 import MongoBinaryDownload from '../MongoBinaryDownload';
@@ -8,8 +7,6 @@ import { DryMongoBinary } from '../DryMongoBinary';
 import * as childProcess from 'child_process';
 import { assertIsError } from '../../__tests__/testUtils/test_utils';
 
-tmp.setGracefulCleanup();
-
 const mockedPath = '/path/to/binary';
 const mockGetMongodPath = jest.fn().mockResolvedValue(mockedPath);
 
@@ -22,16 +19,16 @@ jest.mock('../MongoBinaryDownload', () => {
 jest.mock('child_process');
 
 describe('MongoBinary', () => {
-  let tmpDir: tmp.DirResult;
+  let tmpDir: string;
 
-  beforeEach(() => {
-    tmpDir = tmp.dirSync({ prefix: 'mongo-mem-bin-', unsafeCleanup: true });
+  beforeEach(async () => {
+    tmpDir = await utils.createTmpDir('mongo-mem-bin-');
     DryMongoBinary.binaryCache.clear();
   });
 
   // cleanup
-  afterEach(() => {
-    tmpDir.removeCallback();
+  afterEach(async () => {
+    await utils.removeDir(tmpDir);
     jest.restoreAllMocks(); // restore all mocked functions to original
     DryMongoBinary.binaryCache.clear();
     delete process.env[envName(ResolveConfigVariables.RUNTIME_DOWNLOAD)];
@@ -42,7 +39,7 @@ describe('MongoBinary', () => {
       const version = resolveConfig(ResolveConfigVariables.VERSION);
       utils.assertion(typeof version === 'string', new Error('Expected "version" to be an string'));
       const binPath = await MongoBinary.download({
-        downloadDir: tmpDir.name,
+        downloadDir: tmpDir,
         version,
         arch: 'x64',
         platform: 'linux',
@@ -51,7 +48,7 @@ describe('MongoBinary', () => {
 
       // eg. /tmp/mongo-mem-bin-33990ScJTSRNSsFYf/mongodb-download/a811facba94753a2eba574f446561b7e/mongodb-macOS-x86_64-3.5.5-13-g00ee4f5/
       expect(MongoBinaryDownload).toHaveBeenCalledWith({
-        downloadDir: tmpDir.name,
+        downloadDir: tmpDir,
         platform: os.platform(),
         arch: os.arch(),
         version,

packages/mongodb-memory-server-core/src/util/__tests__/MongoBinaryDownload.test.ts

@@ -8,13 +8,11 @@ import MongoBinaryDownload from '../MongoBinaryDownload';
 import MongoBinaryDownloadUrl from '../MongoBinaryDownloadUrl';
 import { envName, ResolveConfigVariables } from '../resolveConfig';
 import * as utils from '../utils';
-import * as tmp from 'tmp';
 import * as path from 'path';
 import * as yazl from 'yazl';
 import { pack } from 'tar-stream';
 import { createGzip } from 'zlib';
 
-tmp.setGracefulCleanup();
 jest.mock('md5-file');
 
 describe('MongoBinaryDownload', () => {
@@ -305,21 +303,18 @@ describe('MongoBinaryDownload', () => {
   });
 
   describe('extract()', () => {
-    let tmpdir: tmp.DirResult;
+    let tmpdir: string;
 
-    beforeEach(() => {
-      tmpdir = tmp.dirSync({
-        prefix: 'mongo-mem-test-extract-',
-        unsafeCleanup: true,
-      });
+    beforeEach(async () => {
+      tmpdir = await utils.createTmpDir('mongo-mem-test-extract-');
     });
-    afterEach(() => {
-      tmpdir.removeCallback();
+    afterEach(async () => {
+      await utils.removeDir(tmpdir);
     });
 
     it('should extract zip archives', async () => {
-      const zipPath = path.join(tmpdir.name, 'archive.zip');
-      const outPath = path.join(tmpdir.name, 'binary.exe');
+      const zipPath = path.join(tmpdir, 'archive.zip');
+      const outPath = path.join(tmpdir, 'binary.exe');
       const options: MongoBinaryOpts = {
         arch: 'x64',
         downloadDir: path.join(outPath, 'downloadDir'),
@@ -368,8 +363,8 @@ describe('MongoBinaryDownload', () => {
     });
 
     it('should extract tar.gz archives', async () => {
-      const tarPath = path.join(tmpdir.name, 'archive.tgz');
-      const outPath = path.join(tmpdir.name, 'binary');
+      const tarPath = path.join(tmpdir, 'archive.tgz');
+      const outPath = path.join(tmpdir, 'binary');
       const options: MongoBinaryOpts = {
         arch: 'x64',
         downloadDir: path.join(outPath, 'downloadDir'),