ssh-client-wrapper 2.12.4 → 2.13.1

package/lib/index.js

@@ -1,11 +1,12 @@
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const debug = require("debug")("sshClientWrapper:debug:interface");
-const debugVerbose = require("debug")("sshClientWrapper:verbose:interface");
-const { sshExec, canConnect, disconnect, expect } = require("./sshExec.js");
-const { send, recv } = require("./rsyncExec.js");
-const { isArrayOfString, sanityCheck } = require("./util.js");
+import fs from "fs";
+import path from "path";
+import Debug from "debug";
+import * as sshExecModule from "./sshExec.js";
+import * as rsyncExecModule from "./rsyncExec.js";
+import { isArrayOfString, sanityCheck } from "./util.js";
+
+const debug = Debug("sshClientWrapper:debug:interface");
+const debugVerbose = Debug("sshClientWrapper:verbose:interface");
 
 /**
  * Integer means integer number but it is defined as Object for now
@@ -25,10 +26,10 @@ const { isArrayOfString, sanityCheck } = require("./util.js");
  * @param {string | Function} hostInfo.passphrase - passphrase or function which return passphrase of private key
  * @param {string} hostInfo.keyFile - private key filename
  * @param {boolean} hostInfo.noStrictHostKeyChecking - bypass host key checking if true
- * @param {Integer} hostInfo.ControlPersist=180 - how long keep master connection after last client connection has been closed (sec).
- * @param {Integer} hostInfo.ConnectTimeout=60 - timeout used when connectiong to ths SSH server
- * @param {Integer} hostInfo.maxRetry=3 - max number of retry
- * @param {Integer} hostInfo.retryDuration=1000 - duration time (msec) between each retry
+ * @param {Integer} hostInfo.ControlPersist - how long keep master connection after last client connection has been closed (sec).
+ * @param {Integer} hostInfo.ConnectTimeout - timeout used when connectiong to ths SSH server
+ * @param {Integer} hostInfo.maxRetry - max number of retry
+ * @param {Integer} hostInfo.retryDuration - duration time (msec) between each retry
  * @param {string} hostInfo.rcfile - rcfile path which will be sourced before executing actual command
  * @param {string} hostInfo.prependCmd - command string which will be executed before executing actual command
  * @param {string[]} hostInfo.sshOpt - additional options for ssh
@@ -44,13 +45,14 @@ const logAndReject = (message)=>{
  * @class
  */
 class SshClientWrapper {
-  constructor(hostInfo) {
+  constructor(hostInfo, deps = { ...sshExecModule, ...rsyncExecModule }) {
     debug("constructor called for", hostInfo.host);
     debugVerbose("hostInfo=", hostInfo);
     this.hostInfo = { ...hostInfo };
     sanityCheck(this.hostInfo);
     this.hostInfo.masterPty = null;
     this.hostInfo.rsyncVersion = null;
+    this.deps = deps;
 
     if (process.env.HOME) {
       try {
@@ -80,7 +82,7 @@ class SshClientWrapper {
     if (typeof cmd !== "string" || cmd === "") {
       return logAndReject("cmd must be string");
     }
-    return sshExec(this.hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd);
+    return this.deps.sshExec(this.hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd);
   }
 
   /**
@@ -99,7 +101,7 @@ class SshClientWrapper {
     };
     let rt = null;
     try {
-      rt = await sshExec(this.hostInfo, cmd, timeout, cb, rcfile, prependCmd);
+      rt = await this.deps.sshExec(this.hostInfo, cmd, timeout, cb, rcfile, prependCmd);
     } catch (e) {
     //non-zero retrun should be allowed
       if (typeof e.rt === "undefined" || e.rt < 0) {
@@ -138,7 +140,7 @@ class SshClientWrapper {
    */
   async expect(cmd, expects, timeout = 180) {
     debug("expect called", expects);
-    return expect(this.hostInfo, cmd, expects, timeout);
+    return this.deps.expect(this.hostInfo, cmd, expects, timeout);
   }
 
   /**
@@ -169,7 +171,7 @@ class SshClientWrapper {
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
       return logAndReject("opt must be array of string");
     }
-    return send(this.hostInfo, src, dst, opt, timeout);
+    return this.deps.send(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -200,7 +202,7 @@ class SshClientWrapper {
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
       return logAndReject("opt must be array of string");
     }
-    return recv(this.hostInfo, src, dst, opt, timeout);
+    return this.deps.recv(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -215,7 +217,7 @@ class SshClientWrapper {
     if (!Number.isInteger(timeout) || timeout <= 0) {
       return logAndReject("timeout must be positive integer");
     }
-    return canConnect(this.hostInfo, timeout);
+    return this.deps.canConnect(this.hostInfo, timeout);
   }
 
   /**
@@ -223,8 +225,8 @@ class SshClientWrapper {
    */
   async disconnect() {
     debug(`disconnect from ${this.hostInfo.host} called`);
-    disconnect(this.hostInfo);
+    this.deps.disconnect(this.hostInfo);
   }
 }
 
-module.exports = SshClientWrapper;
+export default SshClientWrapper;

package/lib/rsyncExec.js

@@ -1,16 +1,17 @@
-"use strict";
-const path = require("path");
-const fs = require("fs/promises");
-const debug = require("debug")("sshClientWrapper:debug:rsyncExec");
-const debugVerbose = require("debug")("sshClientWrapper:verbose:rsyncExec");
-const { glob, hasMagic } = require("glob");
+import path from "path";
+import fs from "fs/promises";
+import Debug from "debug";
+import { glob, hasMagic } from "glob";
 
-const { connect, retryWrapper, sshExec } = require("./sshExec.js");
-const { fork } = require("./fork.js");
+import { connect, retryWrapper, sshExec } from "./sshExec.js";
+import { fork } from "./fork.js";
 
-const { sshCmd, rsyncCmd, acceptableRsyncRetrunCodes, getSshOption } = require("./util.js");
+import { sshCmd, rsyncCmd, acceptableRsyncRetrunCodes, getSshOption } from "./util.js";
 
-async function checkRsyncVersion(timeout) {
+const debug = Debug("sshClientWrapper:debug:rsyncExec");
+const debugVerbose = Debug("sshClientWrapper:verbose:rsyncExec");
+
+export async function checkRsyncVersion(timeout) {
   const rt = {};
   await fork(null, rsyncCmd, ["--version"], timeout, (output)=>{
     const result = /^rsync *version *(\d+)\.(\d+)\.(\d+).*$/m.exec(output);
@@ -34,7 +35,7 @@ async function checkRsyncVersion(timeout) {
  *
  * this function execute rsync -avv --copy-unsafe-links  src rsync://[user@]host[:port]/dst
  */
-async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
+export async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
   const promises = await Promise.allSettled(argSrc.map((e)=>{
     return glob(e);
@@ -108,7 +109,7 @@ async function isNewRsync(hostInfo) {
  *
  * this function execute rsync -av --copy-unsafe-links  rsync://[user@]host[:port]/src dst
  */
-async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
+export async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
   const src = `${hostInfo.host}:${argSrc.join(" ")}`;
   const sshArgs = getSshOption(hostInfo, true);
@@ -126,8 +127,3 @@ async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   debugVerbose(`recv: ${rsyncCmd} ${args.join(" ")}`);
   return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout, null, acceptableRsyncRetrunCodes), hostInfo);
 }
-module.exports = {
-  checkRsyncVersion,
-  send,
-  recv
-};

package/lib/sshExec.js

@@ -1,11 +1,12 @@
-"use strict";
-const crypto = require("crypto");
-const { setTimeout: setTimeoutPromise } = require("timers/promises");
-const debug = require("debug")("sshClientWrapper:debug:sshExec");
-const debugVerbose = require("debug")("sshClientWrapper:verbose:sshExec");
-const debugSendMasterPty = require("debug")("sshClientWrapper:insecure:sshExec:masterPty");
-const { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } = require("./util.js");
-const { fork, createMasterPty, sshLoginCallback } = require("./fork.js");
+import crypto from "crypto";
+import { setTimeout as setTimeoutPromise } from "timers/promises";
+import Debug from "debug";
+import { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } from "./util.js";
+import { fork, createMasterPty, sshLoginCallback } from "./fork.js";
+
+const debug = Debug("sshClientWrapper:debug:sshExec");
+const debugVerbose = Debug("sshClientWrapper:verbose:sshExec");
+const debugSendMasterPty = Debug("sshClientWrapper:insecure:sshExec:masterPty");
 
 /**
  * @typedef Integer {number} - integer number
@@ -21,7 +22,7 @@ const { fork, createMasterPty, sshLoginCallback } = require("./fork.js");
  * @param {string} prependCmd - command string which will be executed before executing actual command
  * @returns {Integer} - return value of cmd
  */
-async function sshExec(hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd) {
+export async function sshExec(hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd) {
   debug("sshExec called");
   await connect(hostInfo);
   debug("exec", cmd, "on remote server");
@@ -57,7 +58,7 @@ async function sshExec(hostInfo, cmd, timeout, outputCallback, rcfile, prependCm
   }
 }
 
-async function expect(hostInfo, cmd, expects, timeout) {
+export async function expect(hostInfo, cmd, expects, timeout) {
   debug("expect called");
   await connect(hostInfo);
   debugVerbose("exec", cmd, "on remote server with", expects);
@@ -95,7 +96,7 @@ async function expect(hostInfo, cmd, expects, timeout) {
  * @param {object} hostInfo - hostinfo object
  * @param {Integer} timeout - timeout in secconds
  */
-async function canConnect(hostInfo, timeout) {
+export async function canConnect(hostInfo, timeout) {
   debug("canConnect called");
   sanityCheck(hostInfo);
 
@@ -143,7 +144,7 @@ async function existsMaster(hostInfo, argTimeout) {
  * create master ssh connection
  * @param {object} hostInfo - hostinfo object
  */
-async function connect(hostInfo, timeout = 60) {
+export async function connect(hostInfo, timeout = 60) {
   debug("connect called");
 
   if (await existsMaster(hostInfo, timeout)) {
@@ -228,7 +229,7 @@ async function connect(hostInfo, timeout = 60) {
  * remove master session
  * @param {object} hostInfo - hostinfo object
  */
-async function disconnect(hostInfo) {
+export async function disconnect(hostInfo) {
   debug("disconnect called");
 
   if (await existsMaster(hostInfo)) {
@@ -271,7 +272,7 @@ async function disconnect(hostInfo) {
  * @param {Integer} argDuration - time to wait before retring
  * @returns {Integer} - return value of func
  */
-async function retryWrapper(func, hostInfo, argMaxRetry, argDuration) {
+export async function retryWrapper(func, hostInfo, argMaxRetry, argDuration) {
   const maxRetry = argMaxRetry || hostInfo.maxRetry || 3;
   const duration = argDuration || hostInfo.retryDuration || 1000;
   if (maxRetry === 1) {
@@ -301,12 +302,3 @@ async function retryWrapper(func, hostInfo, argMaxRetry, argDuration) {
     }
   }
 }
-
-module.exports = {
-  sshExec,
-  canConnect,
-  connect,
-  disconnect,
-  expect,
-  retryWrapper
-};

package/lib/util.js

@@ -1,18 +1,20 @@
-"use strict";
-const { EOL } = require("os");
-const fs = require("fs");
-const debug = require("debug")("sshClientWrapper:debug:util");
-const { setTimeout: setTimeoutPromise } = require("timers/promises");
+import { EOL } from "os";
+import fs from "fs";
+import Debug from "debug";
+import { setTimeout as setTimeoutPromise } from "timers/promises";
+import Ajv from "ajv";
+import ajvKeywords from "ajv-keywords";
 
-const sshCmd = "ssh";
-const rsyncCmd = "rsync";
-const acceptableRsyncRetrunCodes = [10, 11, 12, 13, 14];
+const debug = Debug("sshClientWrapper:debug:util");
 
-const rePwPrompt = /password:/;
-const rePhPrompt = /Enter passphrase for key/;
-const reNewHostPrompt = /Are you sure you want to continue connecting/;
-const reRemoteHostIdentificationHasChanged = /WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! /;
-const Ajv = require("ajv");
+export const sshCmd = "ssh";
+export const rsyncCmd = "rsync";
+export const acceptableRsyncRetrunCodes = [10, 11, 12, 13, 14];
+
+export const rePwPrompt = /password:/;
+export const rePhPrompt = /Enter passphrase for key/;
+export const reNewHostPrompt = /Are you sure you want to continue connecting/;
+export const reRemoteHostIdentificationHasChanged = /WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! /;
 
 const ajv = new Ajv({
   allErrors: true,
@@ -24,7 +26,7 @@ const ajv = new Ajv({
     error: debug
   }
 });
-require("ajv-keywords")(ajv, "transform");
+ajvKeywords(ajv, "transform");
 
 //never validate password and passphrase value to avoid security insident
 const hostInfoSchema = {
@@ -70,7 +72,7 @@ const validate = ajv.compile(hostInfoSchema);
  * @param {Function} func - function
  * @param {data} data - binary data which can be converted to string
  */
-const buff2String = (func, data)=>{
+export const buff2String = (func, data)=>{
   func(data.toString().replace(/\r\n/g, EOL));
 };
 
@@ -78,7 +80,7 @@ const buff2String = (func, data)=>{
  * check if given hostInfo object is OK
  * @param {object} hostInfo - host information object defined in index.js
  */
-const sanityCheck = (hostInfo)=>{
+export const sanityCheck = (hostInfo)=>{
   debug("sanityCheck called", hostInfo);
 
   //keep password, passphrase, and masterPty before validate.
@@ -155,7 +157,7 @@ function getControlPersistDir(hostInfo) {
  * @param {object} hostInfo - host information object defined in index.js
  * @param {boolean} withoutDestination - return except for hostname
  */
-const getSshOption = (hostInfo, withoutDestination)=>{
+export const getSshOption = (hostInfo, withoutDestination)=>{
   debug("getSshOption called");
   const args = [];
 
@@ -217,7 +219,7 @@ const getSshOption = (hostInfo, withoutDestination)=>{
   return args;
 };
 
-const isArrayOfString = (target)=>{
+export const isArrayOfString = (target)=>{
   if (!Array.isArray(target)) {
     return false;
   }
@@ -234,7 +236,7 @@ const isArrayOfString = (target)=>{
  * @param {Function} logger - logging function
  * @param {string} label - where this function is called
  */
-const sendPty = async (pty, message, logger, label)=>{
+export const sendPty = async (pty, message, logger, label)=>{
   logger(`${label}: ${message}`);
   pty.write(message);
 };
@@ -246,7 +248,7 @@ const sendPty = async (pty, message, logger, label)=>{
  * @param {Function} cb - call back function which will be called after timeout
  * @returns {AbortController} - ac to stop watch dog timer
  */
-const watchDogTimer = (timeout, label, cb)=>{
+export const watchDogTimer = (timeout, label, cb)=>{
   const ac = new AbortController();
   const signal = ac.signal;
   setTimeoutPromise(timeout * 1000, "neverUsedValue", { signal })
@@ -263,19 +265,3 @@ const watchDogTimer = (timeout, label, cb)=>{
     });
   return ac;
 };
-
-module.exports = {
-  sshCmd,
-  rsyncCmd,
-  acceptableRsyncRetrunCodes,
-  rePwPrompt,
-  rePhPrompt,
-  reNewHostPrompt,
-  reRemoteHostIdentificationHasChanged,
-  buff2String,
-  getSshOption,
-  sanityCheck,
-  isArrayOfString,
-  sendPty,
-  watchDogTimer
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.12.4",
+  "version": "2.13.1",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -11,17 +11,17 @@
     "wrapper",
     "rsync"
   ],
+  "type": "module",
   "main": "lib/index.js",
   "scripts": {
     "mocha": "mocha --recursive test",
     "lint": "eslint --fix ./",
-    "test": "nyc --reporter=html --reporter=text mocha",
-    "coverage": "nyc report --reporter=text-lcov > coverage-report.lcov",
-    "postversion": "git push && git push origin $(git describe --abbrev=0 --tags)",
-    "prepare": "husky install"
+    "test": "c8 --reporter=html --reporter=text mocha --recursive test",
+    "coverage": "c8 report --reporter=text-lcov > coverage-report.lcov",
+    "prepare": "husky"
   },
   "engines": {
-    "node": ">=12.9"
+    "node": ">=16.0.0"
   },
   "author": "Naoyuki Sogo <sogo@longtail-software.co.jp>",
   "license": "MIT",
@@ -36,27 +36,30 @@
   "dependencies": {
     "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",
-    "debug": "^4.4.0",
-    "eslint-plugin-chai-friendly": "^1.0.1",
-    "glob": "^10.4.5",
-    "node-pty": "^0.10.1",
-    "promise-retry": "^2.0.1"
+    "debug": "^4.4.1",
+    "glob": "^11.0.3",
+    "node-pty-prebuilt-multiarch": "^0.10.1-pre.5"
   },
   "devDependencies": {
-    "@eslint/js": "^9.19.0",
-    "@stylistic/eslint-plugin": "^3.0.1",
-    "chai": "^4.3.7",
-    "chai-as-promised": "^7.1.1",
-    "chai-fs": "^2.0.0",
-    "eslint-plugin-jsdoc": "^50.6.3",
+    "@eslint/js": "^9.33.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.4",
+    "@semantic-release/npm": "^12.0.2",
+    "@stylistic/eslint-plugin": "^5.2.3",
+    "c8": "^10.1.3",
+    "chai": "^5.3.1",
+    "chai-as-promised": "^8.0.1",
+    "eslint-plugin-chai-friendly": "^1.1.0",
+    "eslint-plugin-jsdoc": "^54.1.0",
     "eslint-plugin-node": "^11.1.0",
-    "fs-extra": "^11.1.1",
-    "husky": "^8.0.0",
-    "lint-staged": "^13.2.1",
-    "mocha": "^10.2.0",
-    "nyc": "^15.1.0",
-    "rewire": "^7.0.0",
-    "sinon": "^15.0.3",
-    "sinon-chai": "^3.7.0"
+    "fs-extra": "^11.3.1",
+    "globals": "^16.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.5",
+    "mocha": "^11.7.1",
+    "semantic-release": "^24.2.7",
+    "sinon": "^21.0.0",
+    "sinon-chai": "^4.0.0"
   }
 }

package/test/getSshOption.js

@@ -1,13 +1,13 @@
-"use strict";
-process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+process.on("unhandledRejection", console.dir);
 
 //setup test framework
-const chai = require("chai");
-const { expect } = require("chai");
-chai.use(require("chai-as-promised"));
+import * as chai from "chai";
+import { expect } from "chai";
+import chaiAsPromised from "chai-as-promised";
+chai.use(chaiAsPromised);
 
 //testee
-const { getSshOption } = require("../lib/util.js");
+import { getSshOption } from "../lib/util.js";
 
 describe("test for getSshOption", ()=>{
   const defaultValues = {

package/test/interface.js

@@ -1,51 +1,53 @@
-"use strict";
-process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+process.on("unhandledRejection", console.dir);
 Error.traceLimit = 100000;
 
 //setup test framework
-const chai = require("chai");
-const { expect } = require("chai");
-const sinon = require("sinon");
-chai.use(require("sinon-chai"));
-chai.use(require("chai-as-promised"));
-
-const rewire = require("rewire");
+import * as chai from "chai";
+import { expect } from "chai";
+import sinon from "sinon";
+import sinonChai from "sinon-chai";
+import chaiAsPromised from "chai-as-promised";
+chai.use(sinonChai);
+chai.use(chaiAsPromised);
 
 //testee
-const SshClientWrapper = rewire("../lib/index.js");
+import SshClientWrapper from "../lib/index.js";
 
 const sshExec = sinon.stub();
 const canConnect = sinon.stub();
 const disconnect = sinon.stub();
+const expectStub = sinon.stub();
 const send = sinon.stub();
 const recv = sinon.stub();
 
-//eslint-disable-next-line no-underscore-dangle
-SshClientWrapper.__set__({
-  sshExec, canConnect, disconnect, send, recv, expect
-});
+const deps = {
+  sshExec,
+  canConnect,
+  disconnect,
+  expect: expectStub,
+  send,
+  recv
+};
 
 describe("test for interface", ()=>{
   describe("test for constructor", ()=>{
     it("should throw error when instanciate with non-empty string host", ()=>{
       expect(()=>{
-        //eslint-disable-next-line no-new
-        new SshClientWrapper({});
+        new SshClientWrapper({}, deps);
       }).to.throw("host is required");
       expect(()=>{
-        //eslint-disable-next-line no-new
-        new SshClientWrapper({ host: "" });
+        new SshClientWrapper({ host: "" }, deps);
       }).to.throw("empty host is not allowed");
     });
     it("should successfully instanciate only with host prop", ()=>{
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("exec");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("execAndGetOutput");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("ls");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("expect");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("send");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("recv");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("canConnect");
-      expect(new SshClientWrapper({ host: "hoge" })).to.have.property("disconnect");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("exec");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("execAndGetOutput");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("ls");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("expect");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("send");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("recv");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("canConnect");
+      expect(new SshClientWrapper({ host: "hoge" }, deps)).to.have.property("disconnect");
     });
   });
   describe("test for public method", ()=>{
@@ -58,12 +60,13 @@ describe("test for interface", ()=>{
     };
     const hostInfo = { ...hostInfoOrg, masterPty: null, rsyncVersion: null };
     beforeEach(()=>{
-      ssh = new SshClientWrapper(hostInfoOrg);
+      ssh = new SshClientWrapper(hostInfoOrg, deps);
       sshExec.reset();
       canConnect.reset();
       disconnect.reset();
       send.reset();
       recv.reset();
+      expectStub.reset();
     });
     describe("test for exec", ()=>{
       it("should call sshExec with cmd", ()=>{

package/test/rsyncExec.js

@@ -1,8 +1,8 @@
-"use strict";
-const fs = require("fs-extra");
-const path = require("path");
-const util = require("util");
-const exec = util.promisify(require("node:child_process").exec);
+import fs from "fs-extra";
+import path from "path";
+import util from "util";
+import { exec as exec_ } from "node:child_process";
+const exec = util.promisify(exec_);
 
 /**
  * to enable debug log dynamically
@@ -14,22 +14,22 @@ const exec = util.promisify(require("node:child_process").exec);
  *         debug.disable();
  */
 
-process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+process.on("unhandledRejection", console.dir);
 Error.traceLimit = 100000;
 
 //setup test framework
-const chai = require("chai");
-const { expect } = require("chai");
-chai.use(require("chai-fs"));
-chai.use(require("chai-as-promised"));
+import * as chai from "chai";
+import { expect } from "chai";
+import chaiAsPromised from "chai-as-promised";
+chai.use(chaiAsPromised);
 
 //testee
-const { checkRsyncVersion, send, recv } = require("../lib/rsyncExec.js");
+import { checkRsyncVersion, send, recv } from "../lib/rsyncExec.js";
 
 //test helpers
-const { sshExec, disconnect } = require("../lib/sshExec.js");
-const hostInfo = require("./testUtil/hostInfo.js");
-const {
+import { sshExec, disconnect } from "../lib/sshExec.js";
+import hostInfo from "./testUtil/hostInfo.js";
+import {
   clearLocalTestFiles,
   clearRemoteTestFiles,
   createLocalFiles,
@@ -40,7 +40,7 @@ const {
   remoteRoot,
   remoteEmptyDir,
   remoteFiles
-} = require("./testUtil/testFiles");
+} from "./testUtil/testFiles.js";
 
 const formatLsOutput = (array)=>{
   const rt = [];
@@ -56,13 +56,13 @@ const formatLsOutput = (array)=>{
 describe("test checkRsyncVersion", async ()=>{
   const { major, minor, patch } = await checkRsyncVersion(1);
   const versionString = `${major}.${minor}.${patch}`;
-  console.log(`==== test with rsync version ${versionString} ====`); //eslint-disable-line no-console
+  console.log(`==== test with rsync version ${versionString} ====`);
   const { stdout } = await exec("rsync --version |grep 'version'");
   expect(stdout).to.match(new RegExp(versionString));
 });
 
 describe("test rsync exec", function () {
-  this.timeout(10000);//eslint-disable-line no-invalid-this
+  this.timeout(10000);
   const rt = [];
   const output = (data)=>{
     rt.push(data);

package/test/sanityCheck.js

@@ -1,13 +1,13 @@
-"use strict";
-process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
+process.on("unhandledRejection", console.dir);
 
 //setup test framework
-const chai = require("chai");
-const { expect } = require("chai");
-chai.use(require("chai-as-promised"));
+import * as chai from "chai";
+import { expect } from "chai";
+import chaiAsPromised from "chai-as-promised";
+chai.use(chaiAsPromised);
 
 //testee
-const { sanityCheck } = require("../lib/util.js");
+import { sanityCheck } from "../lib/util.js";
 
 describe("test for sanityCheck", ()=>{
   const host = "testHostName";