webext-schema 7.0.0 → 7.1.1

package/test/commander.test.js

@@ -7,7 +7,9 @@ import { describe, it } from 'mocha';
 
 /* test */
 import {
-  commander, cleanDirectory, parseCommand
+  commander,
+  cleanDirectory,
+  parseCommand
 } from '../modules/commander.js';
 
 describe('clean directory', () => {
@@ -67,11 +69,7 @@ describe('parse command', () => {
   it('should not parse', () => {
     const stubParse = sinon.stub(commander, 'parse');
     const i = stubParse.callCount;
-    parseCommand([
-      'foo',
-      'bar',
-      'baz'
-    ]);
+    parseCommand(['foo', 'bar', 'baz']);
     assert.strictEqual(stubParse.callCount, i, 'not called');
     stubParse.restore();
   });
@@ -81,11 +79,7 @@ describe('parse command', () => {
     const stubVer = sinon.stub(commander, 'version');
     const i = stubParse.callCount;
     const j = stubVer.callCount;
-    parseCommand([
-      'foo',
-      'bar',
-      '-v'
-    ]);
+    parseCommand(['foo', 'bar', '-v']);
     assert.strictEqual(stubParse.callCount, i + 1, 'called');
     assert.strictEqual(stubVer.callCount, j + 1, 'called');
     stubParse.restore();
@@ -99,11 +93,7 @@ describe('parse command', () => {
     const i = stubParse.callCount;
     const j = stubVer.callCount;
     const k = spyCmd.callCount;
-    parseCommand([
-      'foo',
-      'bar',
-      'clean'
-    ]);
+    parseCommand(['foo', 'bar', 'clean']);
     assert.strictEqual(stubParse.callCount, i + 1, 'called');
     assert.strictEqual(stubVer.callCount, j + 1, 'called');
     assert.strictEqual(spyCmd.callCount, k + 1, 'called');
@@ -119,11 +109,7 @@ describe('parse command', () => {
     const i = stubParse.callCount;
     const j = stubVer.callCount;
     const k = spyCmd.callCount;
-    parseCommand([
-      'foo',
-      'bar',
-      'update'
-    ]);
+    parseCommand(['foo', 'bar', 'update']);
     assert.strictEqual(stubParse.callCount, i + 1, 'called');
     assert.strictEqual(stubVer.callCount, j + 1, 'called');
     assert.strictEqual(spyCmd.callCount, k + 1, 'called');

package/test/common.test.js

@@ -5,7 +5,13 @@ import { describe, it } from 'mocha';
 
 /* test */
 import {
-  getType, isObjectNotEmpty, isString, logErr, logMsg, logWarn, throwErr
+  getType,
+  isObjectNotEmpty,
+  isString,
+  logErr,
+  logMsg,
+  logWarn,
+  throwErr
 } from '../modules/common.js';
 
 describe('getType', () => {

package/test/file-util.test.js

@@ -9,17 +9,28 @@ import { IS_WIN } from '../modules/constant.js';
 
 /* test */
 import {
-  convertUriToFilePath, createDirectory, createFile,
-  getAbsPath, getFileNameFromFilePath, getFileTimestamp, getStat,
-  isDir, isExecutable, isFile, isSubDir, removeDir, removeDirectory, readFile
+  convertUriToFilePath,
+  createDirectory,
+  createFile,
+  getAbsPath,
+  getFileNameFromFilePath,
+  getFileTimestamp,
+  getStat,
+  isDir,
+  isExecutable,
+  isFile,
+  isSubDir,
+  removeDir,
+  removeDirectory,
+  readFile
 } from '../modules/file-util.js';
 
 /* constants */
 const DIR_CWD = process.cwd();
 const PERM_EXEC = 0o700;
 const PERM_FILE = 0o600;
-const TMPDIR = process.env.TMP || process.env.TMPDIR || process.env.TEMP ||
-               os.tmpdir();
+const TMPDIR =
+  process.env.TMP || process.env.TMPDIR || process.env.TEMP || os.tmpdir();
 
 describe('convertUriToFilePath', () => {
   it('should get string', () => {
@@ -71,8 +82,11 @@ describe('convertUriToFilePath', () => {
   });
 
   it('should throw if string is not given', () => {
-    assert.throws(() => convertUriToFilePath(), TypeError,
-      'Expected String but got Undefined');
+    assert.throws(
+      () => convertUriToFilePath(),
+      TypeError,
+      'Expected String but got Undefined'
+    );
   });
 
   it('should get null if protocol does not match', () => {
@@ -92,15 +106,19 @@ describe('createDirectory', () => {
 
   it('should throw if given argument is not a string', async () => {
     await createDirectory().catch(e => {
-      assert.deepStrictEqual(e,
-        new TypeError('Expected String but got Undefined.'));
+      assert.deepStrictEqual(
+        e,
+        new TypeError('Expected String but got Undefined.')
+      );
     });
   });
 
   it('should throw if given second argument is not a number', async () => {
     await createDirectory('/foo/bar', 'baz').catch(e => {
-      assert.deepStrictEqual(e,
-        new TypeError('Expected Number but got String.'));
+      assert.deepStrictEqual(
+        e,
+        new TypeError('Expected Number but got String.')
+      );
     });
   });
 });
@@ -112,7 +130,9 @@ describe('createFile', () => {
     const filePath = path.join(dirPath, 'test.txt');
     const value = 'test file.\n';
     const file = await createFile(filePath, value, {
-      encoding: 'utf8', flag: 'w', mode: PERM_FILE
+      encoding: 'utf8',
+      flag: 'w',
+      mode: PERM_FILE
     });
     assert.strictEqual(file, filePath);
     fs.unlinkSync(file);
@@ -121,21 +141,22 @@ describe('createFile', () => {
 
   it('should throw if first argument is not a string', () => {
     createFile().catch(e => {
-      assert.deepStrictEqual(e,
-        new TypeError('Expected String but got Undefined.'));
+      assert.deepStrictEqual(
+        e,
+        new TypeError('Expected String but got Undefined.')
+      );
     });
   });
 
-  it(
-    'should throw if second argument is not string, buffer, uint8array',
-    () => {
-      const file = path.join(TMPDIR, 'webext-schema', 'test.txt');
-      createFile(file).catch(e => {
-        assert.deepStrictEqual(e,
-          new TypeError('Expected String, Buffer, Uint8Array but got Undefined.'));
-      });
-    }
-  );
+  it('should throw if second argument is not string, buffer, uint8array', () => {
+    const file = path.join(TMPDIR, 'webext-schema', 'test.txt');
+    createFile(file).catch(e => {
+      assert.deepStrictEqual(
+        e,
+        new TypeError('Expected String, Buffer, Uint8Array but got Undefined.')
+      );
+    });
+  });
 });
 
 describe('removeDir', () => {
@@ -147,7 +168,9 @@ describe('removeDir', () => {
     const filePath = path.join(subDirPath, 'test.txt');
     const value = 'test file.\n';
     await createFile(filePath, value, {
-      encoding: 'utf8', flag: 'w', mode: PERM_FILE
+      encoding: 'utf8',
+      flag: 'w',
+      mode: PERM_FILE
     });
     const res1 = await Promise.all([
       fs.existsSync(dirPath),
@@ -175,8 +198,11 @@ describe('removeDir', () => {
     const foo = path.join(TMPDIR, 'foo');
     await fs.mkdirSync(dirPath);
     await fs.mkdirSync(foo);
-    assert.throws(() => removeDir(foo, dirPath), Error,
-                  `${foo} is not a subdirectory of ${dirPath}.`);
+    assert.throws(
+      () => removeDir(foo, dirPath),
+      Error,
+      `${foo} is not a subdirectory of ${dirPath}.`
+    );
     await fs.rmdirSync(dirPath);
     await fs.rmdirSync(foo);
   });
@@ -191,7 +217,9 @@ describe('removeDirectory', () => {
     const filePath = path.join(subDirPath, 'test.txt');
     const value = 'test file.\n';
     await createFile(filePath, value, {
-      encoding: 'utf8', flag: 'w', mode: PERM_FILE
+      encoding: 'utf8',
+      flag: 'w',
+      mode: PERM_FILE
     });
     const res1 = await Promise.all([
       fs.existsSync(dirPath),
@@ -222,8 +250,10 @@ describe('removeDirectory', () => {
     await fs.mkdirSync(dirPath);
     await fs.mkdirSync(foo);
     await removeDirectory(foo, dirPath).catch(e => {
-      assert.deepStrictEqual(e,
-        new Error(`${foo} is not a subdirectory of ${dirPath}.`));
+      assert.deepStrictEqual(
+        e,
+        new Error(`${foo} is not a subdirectory of ${dirPath}.`)
+      );
     });
     await fs.rmdirSync(dirPath);
     await fs.rmdirSync(foo);
@@ -250,8 +280,7 @@ describe('getAbsPath', () => {
   });
 
   it('should throw', () => {
-    assert.throws(() => getAbsPath(),
-      'Expected String but got Undefined');
+    assert.throws(() => getAbsPath(), 'Expected String but got Undefined');
   });
 });
 
@@ -309,9 +338,10 @@ describe('isDir', () => {
 
 describe('isExecutable', () => {
   it('should get true if file is executable', () => {
-    const p = path.resolve(IS_WIN
-      ? path.join('test', 'file', 'test.cmd')
-      : path.join('test', 'file', 'test.sh')
+    const p = path.resolve(
+      IS_WIN
+        ? path.join('test', 'file', 'test.cmd')
+        : path.join('test', 'file', 'test.sh')
     );
     fs.chmodSync(p, PERM_EXEC);
     assert.strictEqual(isExecutable(p), true);

package/test/index.test.js

@@ -1,6 +1,8 @@
 /* api */
 import { strict as assert } from 'node:assert';
-import { describe, it } from 'mocha';
+import process from 'node:process';
+import { describe, it, beforeEach, afterEach } from 'mocha';
+import sinon from 'sinon';
 
 /* test */
 import { Schema } from '../index.js';
@@ -11,3 +13,55 @@ describe('Schema', () => {
     assert.strictEqual(schema instanceof Schema, true);
   });
 });
+
+describe('Process Error Handlers', () => {
+  let sandbox;
+  beforeEach(() => {
+    sandbox = sinon.createSandbox();
+    sandbox.stub(console, 'error');
+    sandbox.stub(process, 'exit');
+  });
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should handle uncaughtException', () => {
+    const listeners = process.listeners('uncaughtException');
+    const targetListener = listeners.find(fn =>
+      fn.toString().includes('Fatal Error (Uncaught Exception)')
+    );
+    assert.ok(
+      targetListener,
+      'Target listener for uncaughtException should be found'
+    );
+    const testError = new Error('Test Uncaught Exception');
+    targetListener(testError);
+    assert.strictEqual(console.error.calledOnce, true);
+    assert.strictEqual(
+      console.error.firstCall.args[0],
+      'Fatal Error (Uncaught Exception):'
+    );
+    assert.strictEqual(console.error.firstCall.args[1], testError);
+    assert.strictEqual(process.exit.calledOnceWithExactly(1), true);
+  });
+
+  it('should handle unhandledRejection', () => {
+    const listeners = process.listeners('unhandledRejection');
+    const targetListener = listeners.find(fn =>
+      fn.toString().includes('Fatal Error (Unhandled Rejection)')
+    );
+    assert.ok(
+      targetListener,
+      'Target listener for unhandledRejection should be found'
+    );
+    const testReason = 'Test Unhandled Rejection';
+    targetListener(testReason);
+    assert.strictEqual(console.error.calledOnce, true);
+    assert.strictEqual(
+      console.error.firstCall.args[0],
+      'Fatal Error (Unhandled Rejection):'
+    );
+    assert.strictEqual(console.error.firstCall.args[1], testReason);
+    assert.strictEqual(process.exit.calledOnceWithExactly(1), true);
+  });
+});