webext-schema 6.0.0 → 7.0.0

package/test/commander.test.js

@@ -0,0 +1,134 @@
+/* api */
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import sinon from 'sinon';
+import { describe, it } from 'mocha';
+
+/* test */
+import {
+  commander, cleanDirectory, parseCommand
+} from '../modules/commander.js';
+
+describe('clean directory', () => {
+  it('should not call funtion', () => {
+    const stubRm = sinon.stub(fs, 'rmSync');
+    const dir = path.resolve('foo');
+    cleanDirectory({ dir });
+    const { called: rmCalled } = stubRm;
+    stubRm.restore();
+    assert.strictEqual(rmCalled, false, 'not called');
+  });
+
+  it('should call funtion', () => {
+    const stubRm = sinon.stub(fs, 'rmSync');
+    const stubInfo = sinon.stub(console, 'info');
+    const dir = path.resolve('test', 'file');
+    cleanDirectory({ dir });
+    const { calledOnce: rmCalled } = stubRm;
+    const { called: infoCalled } = stubInfo;
+    stubRm.restore();
+    stubInfo.restore();
+    assert.strictEqual(rmCalled, true, 'called');
+    assert.strictEqual(infoCalled, false, 'not called');
+  });
+
+  it('should call funtion', () => {
+    const stubRm = sinon.stub(fs, 'rmSync');
+    const stubInfo = sinon.stub(console, 'info');
+    const dir = path.resolve('test', 'file');
+    cleanDirectory({ dir, info: true });
+    const { calledOnce: rmCalled } = stubRm;
+    const { calledOnce: infoCalled } = stubInfo;
+    stubRm.restore();
+    stubInfo.restore();
+    assert.strictEqual(rmCalled, true, 'called');
+    assert.strictEqual(infoCalled, true, 'called');
+  });
+});
+
+describe('parse command', () => {
+  it('should not parse', () => {
+    const stubParse = sinon.stub(commander, 'parse');
+    const i = stubParse.callCount;
+    parseCommand();
+    assert.strictEqual(stubParse.callCount, i, 'not called');
+    stubParse.restore();
+  });
+
+  it('should not parse', () => {
+    const stubParse = sinon.stub(commander, 'parse');
+    const i = stubParse.callCount;
+    parseCommand([]);
+    assert.strictEqual(stubParse.callCount, i, 'not called');
+    stubParse.restore();
+  });
+
+  it('should not parse', () => {
+    const stubParse = sinon.stub(commander, 'parse');
+    const i = stubParse.callCount;
+    parseCommand([
+      'foo',
+      'bar',
+      'baz'
+    ]);
+    assert.strictEqual(stubParse.callCount, i, 'not called');
+    stubParse.restore();
+  });
+
+  it('should parse', () => {
+    const stubParse = sinon.stub(commander, 'parse');
+    const stubVer = sinon.stub(commander, 'version');
+    const i = stubParse.callCount;
+    const j = stubVer.callCount;
+    parseCommand([
+      'foo',
+      'bar',
+      '-v'
+    ]);
+    assert.strictEqual(stubParse.callCount, i + 1, 'called');
+    assert.strictEqual(stubVer.callCount, j + 1, 'called');
+    stubParse.restore();
+    stubVer.restore();
+  });
+
+  it('should parse', () => {
+    const stubParse = sinon.stub(commander, 'parse');
+    const stubVer = sinon.stub(commander, 'version');
+    const spyCmd = sinon.spy(commander, 'command');
+    const i = stubParse.callCount;
+    const j = stubVer.callCount;
+    const k = spyCmd.callCount;
+    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');
+    stubParse.restore();
+    stubVer.restore();
+    spyCmd.restore();
+  });
+
+  it('should parse', () => {
+    const stubParse = sinon.stub(commander, 'parse');
+    const stubVer = sinon.stub(commander, 'version');
+    const spyCmd = sinon.spy(commander, 'command');
+    const i = stubParse.callCount;
+    const j = stubVer.callCount;
+    const k = spyCmd.callCount;
+    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');
+    stubParse.restore();
+    stubVer.restore();
+    spyCmd.restore();
+  });
+});

package/test/common.test.js

@@ -0,0 +1,120 @@
+/* api */
+import { strict as assert } from 'node:assert';
+import sinon from 'sinon';
+import { describe, it } from 'mocha';
+
+/* test */
+import {
+  getType, isObjectNotEmpty, isString, logErr, logMsg, logWarn, throwErr
+} from '../modules/common.js';
+
+describe('getType', () => {
+  it('should get Undefined', () => {
+    assert.strictEqual(getType(), 'Undefined');
+  });
+
+  it('should get Null', () => {
+    assert.strictEqual(getType(null), 'Null');
+  });
+
+  it('should get Object', () => {
+    assert.strictEqual(getType({}), 'Object');
+  });
+
+  it('should get Array', () => {
+    assert.strictEqual(getType([]), 'Array');
+  });
+
+  it('should get Boolean', () => {
+    assert.strictEqual(getType(true), 'Boolean');
+  });
+
+  it('should get Number', () => {
+    assert.strictEqual(getType(1), 'Number');
+  });
+
+  it('should get String', () => {
+    assert.strictEqual(getType('a'), 'String');
+  });
+});
+
+describe('isObjectNotEmpty', () => {
+  it('should get false', () => {
+    const items = [{}, [], ['foo'], '', 'foo', undefined, null, 1, true];
+    for (const item of items) {
+      assert.strictEqual(isObjectNotEmpty(item), false);
+    }
+  });
+
+  it('should get true', () => {
+    const item = {
+      foo: 'bar'
+    };
+    assert.strictEqual(isObjectNotEmpty(item), true);
+  });
+});
+
+describe('isString', () => {
+  it('should get true if string is given', () => {
+    assert.strictEqual(isString('a'), true);
+  });
+
+  it('should get false if given argument is not string', () => {
+    assert.strictEqual(isString(1), false);
+  });
+});
+
+describe('logErr', () => {
+  it('should get false', () => {
+    const msg = 'Log Error test';
+    let errMsg;
+    const consoleError = sinon.stub(console, 'error').callsFake(e => {
+      errMsg = e.message;
+    });
+    const res = logErr(new Error(msg));
+    const { calledOnce } = consoleError;
+    consoleError.restore();
+    assert.strictEqual(calledOnce, true);
+    assert.strictEqual(errMsg, msg);
+    assert.strictEqual(res, false);
+  });
+});
+
+describe('logMsg', () => {
+  it('should get string', () => {
+    const msg = 'Log message test';
+    let logMessage;
+    const consoleLog = sinon.stub(console, 'log').callsFake(m => {
+      logMessage = m;
+    });
+    const res = logMsg(msg);
+    const { calledOnce } = consoleLog;
+    consoleLog.restore();
+    assert.strictEqual(calledOnce, true);
+    assert.strictEqual(logMessage, msg);
+    assert.strictEqual(res, msg);
+  });
+});
+
+describe('logWarn', () => {
+  it('should get false', () => {
+    const msg = 'Log warn test';
+    let warnMsg;
+    const consoleWarn = sinon.stub(console, 'warn').callsFake(m => {
+      warnMsg = m;
+    });
+    const res = logWarn(msg);
+    const { calledOnce } = consoleWarn;
+    consoleWarn.restore();
+    assert.strictEqual(calledOnce, true);
+    assert.strictEqual(warnMsg, msg);
+    assert.strictEqual(res, false);
+  });
+});
+
+describe('throwErr', () => {
+  it('should throw', () => {
+    const e = new Error('Error');
+    assert.throws(() => throwErr(e));
+  });
+});

package/test/constant.test.js

@@ -0,0 +1,34 @@
+/* api */
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'mocha';
+import { isString } from '../modules/common.js';
+
+/* test */
+import { CHAR, INDENT, IS_WIN } from '../modules/constant.js';
+
+describe('string constants', () => {
+  it('should get string', () => {
+    const arr = [CHAR];
+    arr.forEach(i => {
+      assert.strictEqual(isString(i), true);
+    });
+  });
+});
+
+describe('number constants', () => {
+  it('should get number', () => {
+    const arr = [INDENT];
+    arr.forEach(i => {
+      assert.strictEqual(typeof i, 'number');
+    });
+  });
+});
+
+describe('boolean constants', () => {
+  it('should get boolean', () => {
+    const arr = [IS_WIN];
+    arr.forEach(i => {
+      assert.strictEqual(typeof i, 'boolean');
+    });
+  });
+});

package/test/file/test 2.cmd

@@ -0,0 +1,2 @@
+@echo off
+exit /B 0

package/test/file/test 2.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exit 0

package/test/file/test.cmd

@@ -0,0 +1,2 @@
+@echo off
+exit /B 0

package/test/file/test.js

@@ -0,0 +1 @@
+'use strict';

package/test/file/test.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exit 0

package/test/file/test.txt

@@ -0,0 +1 @@
+test file

package/test/file-util.test.js

@@ -0,0 +1,370 @@
+/* api */
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { describe, it } from 'mocha';
+import { IS_WIN } from '../modules/constant.js';
+
+/* test */
+import {
+  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();
+
+describe('convertUriToFilePath', () => {
+  it('should get string', () => {
+    const p = path.resolve('foo/bar');
+    let u;
+    if (IS_WIN) {
+      const reg = new RegExp(`\\${path.sep}`, 'g');
+      u = new URL(`file:///${p.replace(reg, '/')}`).href;
+    } else {
+      u = new URL(`file://${p}`).href;
+    }
+    assert.strictEqual(convertUriToFilePath(u), p);
+  });
+
+  it('should get string', () => {
+    const p = path.resolve('foo/bar baz');
+    let u;
+    if (IS_WIN) {
+      const reg = new RegExp(`\\${path.sep}`, 'g');
+      u = new URL(`file:///${p.replace(reg, '/')}`).href;
+    } else {
+      u = new URL(`file://${p}`).href;
+    }
+    assert.strictEqual(convertUriToFilePath(u), p);
+  });
+
+  it('should get string', () => {
+    const p = path.resolve('/foo/bar/baz');
+    let u;
+    if (IS_WIN) {
+      const reg = new RegExp(`\\${path.sep}`, 'g');
+      u = new URL(`file:///${p.replace(reg, '/')}`).href;
+    } else {
+      u = new URL(`file://${p}`).href;
+    }
+    assert.strictEqual(convertUriToFilePath(u), p);
+  });
+
+  it('should get string', () => {
+    const p = path.resolve('/foo/bar/baz');
+    let u;
+    if (IS_WIN) {
+      const reg = new RegExp(`\\${path.sep}`, 'g');
+      u = new URL(`file://localhost/${p.replace(reg, '/')}`).href;
+    } else {
+      u = new URL(`file://localhost${p}`).href;
+    }
+    assert.strictEqual(convertUriToFilePath(u), p);
+  });
+
+  it('should throw if string is not given', () => {
+    assert.throws(() => convertUriToFilePath(), TypeError,
+      'Expected String but got Undefined');
+  });
+
+  it('should get null if protocol does not match', () => {
+    const uri = 'http://example.com';
+    assert.deepEqual(convertUriToFilePath(uri), null);
+  });
+});
+
+describe('createDirectory', () => {
+  it('should get string', async () => {
+    const dirString = path.join(TMPDIR, 'webext-schema', '1');
+    const dir = await createDirectory(dirString);
+    assert.strictEqual(dir, dirString);
+    fs.rmdirSync(dirString);
+    fs.rmdirSync(path.join(TMPDIR, 'webext-schema'));
+  });
+
+  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.'));
+    });
+  });
+
+  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.'));
+    });
+  });
+});
+
+describe('createFile', () => {
+  it('should get string', async () => {
+    const dirPath = path.join(TMPDIR, 'webext-schema');
+    fs.mkdirSync(dirPath);
+    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
+    });
+    assert.strictEqual(file, filePath);
+    fs.unlinkSync(file);
+    fs.rmdirSync(dirPath);
+  });
+
+  it('should throw if first argument is not a string', () => {
+    createFile().catch(e => {
+      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.'));
+      });
+    }
+  );
+});
+
+describe('removeDir', () => {
+  it("should remove dir and it's files", async () => {
+    const dirPath = path.join(TMPDIR, 'webext-schema');
+    fs.mkdirSync(dirPath);
+    const subDirPath = path.join(dirPath, 'foo');
+    fs.mkdirSync(subDirPath);
+    const filePath = path.join(subDirPath, 'test.txt');
+    const value = 'test file.\n';
+    await createFile(filePath, value, {
+      encoding: 'utf8', flag: 'w', mode: PERM_FILE
+    });
+    const res1 = await Promise.all([
+      fs.existsSync(dirPath),
+      fs.existsSync(subDirPath),
+      fs.existsSync(filePath)
+    ]);
+    removeDir(dirPath, TMPDIR);
+    const res2 = await Promise.all([
+      fs.existsSync(dirPath),
+      fs.existsSync(subDirPath),
+      fs.existsSync(filePath)
+    ]);
+    assert.deepEqual(res1, [true, true, true]);
+    assert.deepEqual(res2, [false, false, false]);
+  });
+
+  it('should ignore if dir is not a directory', () => {
+    const foo = path.resolve('foo');
+    assert.strictEqual(isDir(foo), false);
+    assert.doesNotThrow(() => removeDir(foo, TMPDIR));
+  });
+
+  it('should throw if dir is not subdirectory of base dir', async () => {
+    const dirPath = path.join(TMPDIR, 'webext-schema');
+    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}.`);
+    await fs.rmdirSync(dirPath);
+    await fs.rmdirSync(foo);
+  });
+});
+
+describe('removeDirectory', () => {
+  it("should remove dir and it's files", async () => {
+    const dirPath = path.join(TMPDIR, 'webext-schema');
+    fs.mkdirSync(dirPath);
+    const subDirPath = path.join(dirPath, 'foo');
+    fs.mkdirSync(subDirPath);
+    const filePath = path.join(subDirPath, 'test.txt');
+    const value = 'test file.\n';
+    await createFile(filePath, value, {
+      encoding: 'utf8', flag: 'w', mode: PERM_FILE
+    });
+    const res1 = await Promise.all([
+      fs.existsSync(dirPath),
+      fs.existsSync(subDirPath),
+      fs.existsSync(filePath)
+    ]);
+    await removeDirectory(dirPath, TMPDIR);
+    const res2 = await Promise.all([
+      fs.existsSync(dirPath),
+      fs.existsSync(subDirPath),
+      fs.existsSync(filePath)
+    ]);
+    assert.deepEqual(res1, [true, true, true]);
+    assert.deepEqual(res2, [false, false, false]);
+  });
+
+  it('should ignore if dir is not a directory', async () => {
+    const foo = path.resolve('foo');
+    assert.strictEqual(isDir(foo), false);
+    await removeDirectory(foo, TMPDIR).catch(e => {
+      assert.isUndefined(e);
+    });
+  });
+
+  it('should throw if dir is not subdirectory of base dir', async () => {
+    const dirPath = path.join(TMPDIR, 'webext-schema');
+    const foo = path.join(TMPDIR, 'foo');
+    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}.`));
+    });
+    await fs.rmdirSync(dirPath);
+    await fs.rmdirSync(foo);
+  });
+});
+
+describe('getAbsPath', () => {
+  it('should get string', () => {
+    const p = 'test.txt';
+    const n = path.resolve(DIR_CWD, p);
+    assert.strictEqual(getAbsPath(p), n);
+  });
+
+  it('should get string', () => {
+    const p = '~/test.txt';
+    const n = path.resolve(DIR_CWD, '~/test.txt');
+    assert.strictEqual(getAbsPath(p), n);
+  });
+
+  it('should get string', () => {
+    const p = 'bar/../foo/test.txt';
+    const n = path.resolve(DIR_CWD, 'foo/test.txt');
+    assert.strictEqual(getAbsPath(p), n);
+  });
+
+  it('should throw', () => {
+    assert.throws(() => getAbsPath(),
+      'Expected String but got Undefined');
+  });
+});
+
+describe('getFileNameFromFilePath', () => {
+  it('should get string', () => {
+    const p = path.resolve(path.join('test', 'file', 'test.sh'));
+    assert.strictEqual(getFileNameFromFilePath(p), 'test');
+  });
+
+  it('should get default string', () => {
+    const p = path.resolve(path.join('test', 'file'));
+    assert.strictEqual(getFileNameFromFilePath(p), 'index');
+  });
+});
+
+describe('getFileTimestamp', () => {
+  it('should get positive integer', () => {
+    const p = path.resolve(path.join('test', 'file', 'test.sh'));
+    assert.strictEqual(getFileTimestamp(p) > 0, true);
+  });
+
+  it('should get 0 if file does not exist', () => {
+    const p = path.resolve(path.join('test', 'file', 'foo.txt'));
+    assert.strictEqual(getFileTimestamp(p), 0);
+  });
+});
+
+describe('getStat', () => {
+  it('should be an object', () => {
+    const p = path.resolve(path.join('test', 'file', 'test.sh'));
+    assert.strictEqual(typeof getStat(p), 'object');
+  });
+
+  it('should get null if given argument is not string', () => {
+    assert.deepEqual(getStat(), null);
+  });
+
+  it('should get null if file does not exist', () => {
+    const p = path.resolve(path.join('test', 'file', 'foo.txt'));
+    assert.deepEqual(getStat(p), null);
+  });
+});
+
+describe('isDir', () => {
+  it('should get true if dir exists', () => {
+    const p = path.resolve(path.join('test', 'file'));
+    assert.strictEqual(isDir(p), true);
+  });
+
+  it('should get false if dir does not exist', () => {
+    const p = path.resolve(path.join('test', 'foo'));
+    assert.strictEqual(isDir(p), false);
+  });
+});
+
+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')
+    );
+    fs.chmodSync(p, PERM_EXEC);
+    assert.strictEqual(isExecutable(p), true);
+  });
+
+  it('should get false if file is not executable', () => {
+    const p = path.resolve(path.join('test', 'file', 'test.txt'));
+    assert.strictEqual(isExecutable(p), false);
+  });
+
+  it('should get false if file does not exist', () => {
+    const p = path.resolve(path.join('test', 'file', 'foo.txt'));
+    assert.strictEqual(isExecutable(p), false);
+  });
+});
+
+describe('isFile', () => {
+  it('should get true if file exists', () => {
+    const p = path.resolve(path.join('test', 'file', 'test.txt'));
+    assert.strictEqual(isFile(p), true);
+  });
+
+  it('should get false if file does not exist', () => {
+    const p = path.resolve(path.join('test', 'file', 'foo.txt'));
+    assert.strictEqual(isFile(p), false);
+  });
+});
+
+describe('isSubDir', () => {
+  it('should get true if dir is subdirectory of base dir', () => {
+    const d = path.resolve(path.join('test', 'file'));
+    const b = path.resolve('test');
+    assert.strictEqual(isSubDir(d, b), true);
+  });
+
+  it('should get false if dir is not subdirectory of base dir', () => {
+    const d = path.resolve('foo');
+    const b = path.resolve('test');
+    assert.strictEqual(isSubDir(d, b), false);
+  });
+});
+
+describe('readFile', () => {
+  it('should throw', async () => {
+    await readFile('foo/bar').catch(e => {
+      assert.strictEqual(e.message, 'foo/bar is not a file.');
+    });
+  });
+
+  it('should get file', async () => {
+    const p = path.resolve(path.join('test', 'file', 'test.txt'));
+    const opt = { encoding: 'utf8', flag: 'r' };
+    const file = await readFile(p, opt);
+    assert.strictEqual(file, 'test file\n');
+  });
+});

package/test/index.test.js

@@ -0,0 +1,13 @@
+/* api */
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'mocha';
+
+/* test */
+import { Schema } from '../index.js';
+
+describe('Schema', () => {
+  it('should be instance of Schema', () => {
+    const schema = new Schema();
+    assert.strictEqual(schema instanceof Schema, true);
+  });
+});