feat(errors): unfiy binary X_OK checking and throwing errors

Author: hasezoey

docs/guides/error-warning-details.md

@@ -67,3 +67,11 @@ This Error gets thrown when this package runs on an unsupported architecture by
 ## AuthNotObjectError
 
 *extend documentation*
+
+## InsufficientPermissionsError
+
+*extend documentation*
+
+## BinaryNotFoundError
+
+*extend documentation*

packages/mongodb-memory-server-core/src/util/DryMongoBinary.ts

@@ -1,7 +1,6 @@
-import { promises as fspromises, constants } from 'fs';
 import debug from 'debug';
 import { envToBool, resolveConfig, ResolveConfigVariables } from './resolveConfig';
-import { isNullOrUndefined, pathExists } from './utils';
+import { checkBinaryPermissions, isNullOrUndefined, pathExists } from './utils';
 import * as path from 'path';
 import { arch, homedir, platform } from 'os';
 import findCacheDir from 'find-cache-dir';
@@ -148,9 +147,10 @@ export class DryMongoBinary {
    * @return System Binary path or undefined
    */
   static async getSystemPath(systemBinary: string): Promise<string | undefined> {
+    // REFACTOR: change this function to always return "string"
     log('getSystempath');
     try {
-      await fspromises.access(systemBinary, constants.X_OK); // check if the provided path exists and has the execute bit for current user
+      await checkBinaryPermissions(systemBinary);
 
       log(`getSystemPath: found system binary path at "${systemBinary}"`);
 

packages/mongodb-memory-server-core/src/util/MongoInstance.ts

@@ -2,11 +2,17 @@ import { ChildProcess, fork, spawn, SpawnOptions } from 'child_process';
 import * as path from 'path';
 import { MongoBinary, MongoBinaryOpts } from './MongoBinary';
 import debug from 'debug';
-import { assertion, uriTemplate, isNullOrUndefined, killProcess, ManagerBase } from './utils';
+import {
+  assertion,
+  uriTemplate,
+  isNullOrUndefined,
+  killProcess,
+  ManagerBase,
+  checkBinaryPermissions,
+} from './utils';
 import { lt } from 'semver';
 import { EventEmitter } from 'events';
 import { MongoClient, MongoClientOptions, MongoNetworkError } from 'mongodb';
-import { promises as fspromises, constants } from 'fs';
 import { KeyFileMissingError, StartBinaryFailedError } from './errors';
 
 // ignore the nodejs warning for coverage
@@ -294,15 +300,7 @@ export class MongoInstance extends EventEmitter implements ManagerBase {
     });
 
     const mongoBin = await MongoBinary.getPath(this.binaryOpts);
-    try {
-      await fspromises.access(mongoBin, constants.X_OK);
-    } catch (err) {
-      console.error(
-        `Mongod File at "${mongoBin}" does not have sufficient permissions to be used by this process\n` +
-          'Needed Permissions: Execute (--x)\n'
-      );
-      throw err;
-    }
+    await checkBinaryPermissions(mongoBin);
     this.debug('start: Starting Processes');
     this.mongodProcess = this._launchMongod(mongoBin);
     // This assertion is here because somewhere between nodejs 12 and 16 the types for "childprocess.pid" changed to include "| undefined"

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

@@ -1,6 +1,11 @@
 import { Stats, promises as fspromises } from 'fs';
 import { ChildProcess } from 'child_process';
 import * as utils from '../utils';
+import * as tmp from 'tmp';
+import { resolve } from 'path';
+import { BinaryNotFoundError, InsufficientPermissionsError } from '../errors';
+
+tmp.setGracefulCleanup();
 
 describe('utils', () => {
   describe('uriTemplate', () => {
@@ -133,4 +138,58 @@ describe('utils', () => {
       expect(utils.getHost('mongodb://user:pass@localhost:0000/')).toEqual('localhost:0000');
     });
   });
+
+  describe('checkBinaryPermissions', () => {
+    let tmpDir: tmp.DirResult;
+    beforeEach(() => {
+      jest.restoreAllMocks();
+      tmpDir = tmp.dirSync({ prefix: 'mongo-mem-utils-', unsafeCleanup: true });
+    });
+    afterEach(() => {
+      tmpDir.removeCallback();
+    });
+
+    it('should throw nothing', async () => {
+      jest.spyOn(fspromises, 'access');
+      const binaryPath = resolve(tmpDir.name, 'noThrow');
+
+      await fspromises.writeFile(binaryPath, '', { mode: 0o777 });
+
+      await utils.checkBinaryPermissions(binaryPath);
+
+      expect(fspromises.access).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw InsufficientPermissionsError', async () => {
+      jest.spyOn(fspromises, 'access');
+      const binaryPath = resolve(tmpDir.name, 'throwInsufficientPermissionsError');
+
+      await fspromises.writeFile(binaryPath, '', { mode: 0o600 });
+
+      try {
+        await utils.checkBinaryPermissions(binaryPath);
+        fail('Expected "utils.checkBinaryPermissions" to throw');
+      } catch (err) {
+        expect(err).toBeInstanceOf(InsufficientPermissionsError);
+        expect(err).toHaveProperty('path', binaryPath);
+      }
+
+      expect(fspromises.access).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw BinaryNotFoundError', async () => {
+      jest.spyOn(fspromises, 'access');
+      const binaryPath = resolve(tmpDir.name, 'doesNotExist');
+
+      try {
+        await utils.checkBinaryPermissions(binaryPath);
+        fail('Expected "utils.checkBinaryPermissions" to throw');
+      } catch (err) {
+        expect(err).toBeInstanceOf(BinaryNotFoundError);
+        expect(err).toHaveProperty('path', binaryPath);
+      }
+
+      expect(fspromises.access).toHaveBeenCalledTimes(1);
+    });
+  });
 });

packages/mongodb-memory-server-core/src/util/errors.ts

@@ -65,6 +65,7 @@ export class EnsureInstanceError extends Error {
   }
 }
 
+// REFACTOR: merge this error with BinaryNotFoundError
 export class NoSystemBinaryFoundError extends Error {
   constructor(public binaryPath: string) {
     super(
@@ -102,3 +103,15 @@ export class AuthNotObjectError extends Error {
     super('"auth" was not a object when it was expected!');
   }
 }
+
+export class InsufficientPermissionsError extends Error {
+  constructor(public path: string) {
+    super(`File "${path}" does not have the required Permissions, required Permissions: "--x"`);
+  }
+}
+
+export class BinaryNotFoundError extends Error {
+  constructor(public path: string) {
+    super(`No Binary at path "${path}" was found! (ENOENT)`);
+  }
+}

packages/mongodb-memory-server-core/src/util/utils.ts

@@ -1,8 +1,9 @@
 import debug from 'debug';
 import { ChildProcess } from 'child_process';
 import { AutomaticAuth } from '../MongoMemoryServer';
-import { promises as fspromises, Stats } from 'fs';
+import { promises as fspromises, Stats, constants } from 'fs';
 import { LinuxOS } from './getos';
+import { BinaryNotFoundError, InsufficientPermissionsError } from './errors';
 
 const log = debug('MongoMS:utils');
 
@@ -228,3 +229,22 @@ export abstract class ManagerAdvanced extends ManagerBase {
   abstract getUri(otherDB?: string | boolean): string;
   abstract cleanup(force: boolean): Promise<void>;
 }
+
+/**
+ * Check that the Binary has sufficient Permissions to be executed
+ * @param path The Path to check
+ */
+export async function checkBinaryPermissions(path: string): Promise<void> {
+  try {
+    await fspromises.access(path, constants.X_OK); // check if the provided path exists and has the execute bit for current user
+  } catch (err) {
+    if (err?.code === 'EACCES') {
+      throw new InsufficientPermissionsError(path);
+    }
+    if (err?.code === 'ENOENT') {
+      throw new BinaryNotFoundError(path);
+    }
+
+    throw err;
+  }
+}