ssh-client-wrapper 2.11.0 → 2.13.0

package/test/sshExec.js

@@ -1,37 +1,41 @@
-"use strict";
-const path = require("path");
+import path from "path";
+import { fileURLToPath } from "url";
 
-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"));
+//setup test framework
+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);
 
 const sshout = sinon.stub();
 
-// testee
-const { sshExec, canConnect, disconnect, ls } = require("../lib/sshExec.js");
+//testee
+import { sshExec, canConnect, disconnect } from "../lib/sshExec.js";
 
-// test helpers
-const hostInfo = require("./testUtil/hostInfo.js");
-const { clearRemoteTestFiles, clearLocalTestFiles, createRemoteFiles, nonExisting, remoteRoot, remoteEmptyDir } = require("./testUtil/testFiles.js");
-const { send } = require("../lib/rsyncExec.js");
+//test helpers
+import hostInfo from "./testUtil/hostInfo.js";
+import { clearRemoteTestFiles, clearLocalTestFiles, nonExisting } from "./testUtil/testFiles.js";
+import { send } from "../lib/rsyncExec.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 describe("test for ssh execution", function () {
   const rcfilePath = "/home/testuser/testrc";
-  this.timeout(65000);// eslint-disable-line no-invalid-this
-  beforeEach(async () => {
+  this.timeout(65000);
+  beforeEach(async ()=>{
     sshout.reset();
     await clearRemoteTestFiles(hostInfo);
   });
-  before(async () => {
+  before(async ()=>{
     await send(hostInfo, [path.resolve(__dirname, "./testUtil/testrc")], rcfilePath, [], 0);
   });
-  after(async () => {
+  after(async ()=>{
     if (!process.env.TEST_KEEP_FILES) {
       await clearRemoteTestFiles(hostInfo);
       await clearLocalTestFiles();
@@ -39,28 +43,28 @@ describe("test for ssh execution", function () {
     }
     await disconnect(hostInfo);
   });
-  describe("#exec", () => {
+  describe("#exec", ()=>{
     const testText = "hoge";
-    it("should execute single command with stdout", async () => {
+    it("should execute single command with stdout", async ()=>{
       const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout);
       expect(rt).to.equal(0);
       expect(sshout).to.be.called;
 
       expect(sshout).to.be.calledWithMatch(/^hoge/);
     });
-    it("should execute single command with stderr", async () => {
+    it("should execute single command with stderr", async ()=>{
       const rt = await sshExec(hostInfo, `echo ${testText} >&2`, 0, sshout);
       expect(rt).to.equal(0);
       expect(sshout).to.be.called;
       expect(sshout).to.be.calledWithMatch(/^hoge/);
     });
-    it("should execute 2 command by prependCmd ", async () => {
+    it("should execute 2 command by prependCmd ", async ()=>{
       const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout, null, "echo foo");
       expect(rt).to.equal(0);
       expect(sshout).to.be.calledOnce;
       expect(sshout).to.be.calledWithMatch(/^foo\nhoge\n/);
     });
-    it("should execute 2 command by hostInfo.prependCmd ", async () => {
+    it("should execute 2 command by hostInfo.prependCmd ", async ()=>{
       hostInfo.prependCmd = "echo foo";
       const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout, null);
       expect(rt).to.equal(0);
@@ -68,13 +72,13 @@ describe("test for ssh execution", function () {
       expect(sshout).to.be.calledWithMatch(/^foo\nhoge\n/);
       delete hostInfo.prependCmd;
     });
-    it("should execute 2 command by rcfile", async () => {
+    it("should execute 2 command by rcfile", async ()=>{
       const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout, rcfilePath);
       expect(rt).to.equal(0);
       expect(sshout).to.be.calledOnce;
       expect(sshout).to.be.calledWithMatch(/^this is test rcfile\nhoge\n/);
     });
-    it("should execute 2 command by hostInfo.prependCmd ", async () => {
+    it("should execute 2 command by hostInfo.prependCmd ", async ()=>{
       hostInfo.rcfile = rcfilePath;
       const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout, null);
       expect(rt).to.equal(0);
@@ -82,92 +86,60 @@ describe("test for ssh execution", function () {
       expect(sshout).to.be.calledWithMatch(/^this is test rcfile\nhoge\n/);
       delete hostInfo.rcfile;
     });
-    // please note that exec() resolves with non-zero value
-    // (126 permission deny or 127 file not found)
-    // but does not reject in following 2 cases
-    it("should not execute command which do not have exec permission", async () => {
+    //please note that exec() resolves with non-zero value
+    //(126 permission deny or 127 file not found)
+    //but does not reject in following 2 cases
+    it("should not execute command which do not have exec permission", async ()=>{
       await sshExec(hostInfo, "echo echo hoge >hoge");
       await sshExec(hostInfo, "chmod ugo-x hoge");
       const rt = await sshExec(hostInfo, "./hoge");
       expect(rt).to.equal(126);
     });
-    it("should resolve with 127 if command is not found", async () => {
+    it("should resolve with 127 if command is not found", async ()=>{
       const rt = await sshExec(hostInfo, `./${nonExisting}`);
       expect(rt).to.equal(127);
     });
-    it("should be rejected if timeout expired", async () => {
+    it("should be rejected if timeout expired", async ()=>{
       return expect(sshExec(hostInfo, "sleep 60", 1)).to.be.rejectedWith("watchdog timer expired");
     });
   });
-  describe("#canConnect", () => {
+  describe("#canConnect", ()=>{
     let hostInfo2;
-    beforeEach(async () => {
+    beforeEach(async ()=>{
       await disconnect(hostInfo);
       hostInfo2 = { ...hostInfo };
       hostInfo2.masterPty = null;
     });
-    afterEach(async () => {
+    afterEach(async ()=>{
       await disconnect(hostInfo2);
     });
-    it("should be resolved with true", async () => {
+    it("should be resolved with true", async ()=>{
       return expect(await canConnect(hostInfo2, 5)).to.be.true;
     });
-    it("should be rejected if user does not exist", async () => {
+    it("should be rejected if user does not exist", async ()=>{
       hostInfo2.user = "xxxx";
       return expect(canConnect(hostInfo2, 2)).to.be.rejected;
     });
-    it("should be rejected if password is wrong", async () => {
+    it("should be rejected if password is wrong", async ()=>{
       hostInfo2.password = "xxxx";
       return expect(canConnect(hostInfo2, 2)).to.be.rejected;
     });
-    it("should be rejected if host does not exist", async () => {
+    it("should be rejected if host does not exist", async ()=>{
       hostInfo2.host = "foo.bar.example.com";
       return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
     });
-    it("should be rejected if host(ip address) does not exist", async () => {
+    it("should be rejected if host(ip address) does not exist", async ()=>{
       hostInfo2.host = "192.0.2.1";
-      hostInfo2.ConnectTimeout = 8; // please note each test will be timed out in 20 seconds
+      hostInfo2.ConnectTimeout = 8; //please note each test will be timed out in 20 seconds
       return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith(255);
     });
-    it("should be rejected if port number is out of range(-1)", async () => {
+    it("should be rejected if port number is out of range(-1)", async ()=>{
       hostInfo2.port = -1;
       return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith("invalid port specified -1");
     });
-    it("should be rejected if port number is out of range(65536)", async () => {
+    it("should be rejected if port number is out of range(65536)", async ()=>{
       hostInfo2.port = 65536;
       return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith("invalid port specified 65536");
     });
   });
-  describe("#ls", () => {
-    beforeEach(async () => {
-      await createRemoteFiles(hostInfo);
-    });
-    it("should return array of file and directory names in the specified directory", async () => {
-      expect(await ls(hostInfo, remoteRoot, [], 0)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-    });
-    it("should return array which has only specified file", async () => {
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "foo"), [], 0)).to.eql([path.posix.join(remoteRoot, "foo")]);
-    });
-    it("should return 'No such file or directory' if non-existing path is specified", async () => {
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, nonExisting), [], 0)).to.match(/No such file or directory/);
-    });
-    it("should return only matched filenames, if glob is specified", async () => {
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "b*"), [], 0)).to.have.members(["bar", "baz"].map((e) => {
-        return path.posix.join(remoteRoot, e);
-      }));
-    });
-    it("should return only matched filenames src contains multipl glob pattern", async () => {
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "h*", "p[iu]yo"), [], 0)).to.have.members(["piyo", "puyo"].map((e) => {
-        return path.posix.join(remoteRoot, "hoge", e);
-      }));
-    });
-    it("should return only matched filenames, if specified glob contains /", async () => {
-      expect(await ls(hostInfo, path.posix.join(remoteRoot, "hoge/*yo"), [], 0)).to.have.members(["piyo", "puyo", "poyo"].map((e) => {
-        return path.posix.join(remoteRoot, "hoge", e);
-      }));
-    });
-    it("should return empty array if specified target is empty directory", async () => {
-      expect(await ls(hostInfo, remoteEmptyDir, [], 0)).to.be.an("array").that.is.empty;
-    });
-  });
 });

package/test/testUtil/hostInfo.js

@@ -1,5 +1,4 @@
-"use strict";
-module.exports = {
+export default {
   host: process.env.TEST_HOST || "localhost",
   user: process.env.TEST_USER || null,
   port: process.env.TEST_PORT || 22,

package/test/testUtil/testFiles.js

@@ -1,8 +1,7 @@
-"use strict";
-const fs = require("fs-extra");
-const path = require("path");
+import fs from "fs-extra";
+import path from "path";
 
-const { sshExec } = require("../../lib/sshExec.js");
+import { sshExec } from "../../lib/sshExec.js";
 
 /*
  * test directory tree
@@ -47,44 +46,56 @@ const nonExisting = "ARSSH_nonExisting";
 /*
  * prepare local files which contain its filename
  */
-async function createLocalFiles () {
+/**
+ *
+ */
+export async function createLocalFiles() {
   const localDir2 = path.join(localRoot, "hoge");
   const promises = [];
   await fs.mkdir(localRoot);
   await fs.mkdir(localDir2);
   promises.push(fs.mkdir(localEmptyDir));
-  localFiles.forEach((localFile) => {
+  localFiles.forEach((localFile)=>{
     promises.push(fs.writeFile(localFile, `${localFile}\n`));
   });
   return Promise.all(promises);
 }
 
-async function clearLocalTestFiles () {
+/**
+ *
+ */
+export async function clearLocalTestFiles() {
   return fs.remove(localRoot);
 }
 
-async function createRemoteFiles (hostInfo) {
-  // create remote files
+/**
+ *
+ * @param hostInfo
+ */
+export async function createRemoteFiles(hostInfo) {
+  //create remote files
   await sshExec(hostInfo, `mkdir -p ${remoteRoot}/hoge`);
   await sshExec(hostInfo, `mkdir -p ${remoteEmptyDir}`);
-  const script = remoteFiles.reduce((a, remoteFile) => {
+  const script = remoteFiles.reduce((a, remoteFile)=>{
     return `${a}echo ${remoteFile} > ${remoteFile};`;
   }, "");
   return sshExec(hostInfo, `${script}`);
 }
 
-async function clearRemoteTestFiles (hostInfo) {
+/**
+ *
+ * @param hostInfo
+ */
+export async function clearRemoteTestFiles(hostInfo) {
   return sshExec(hostInfo, `rm -fr ${remoteRoot}`);
 }
 
-module.exports.createLocalFiles = createLocalFiles;
-module.exports.createRemoteFiles = createRemoteFiles;
-module.exports.clearLocalTestFiles = clearLocalTestFiles;
-module.exports.clearRemoteTestFiles = clearRemoteTestFiles;
-module.exports.localRoot = localRoot;
-module.exports.localEmptyDir = localEmptyDir;
-module.exports.localFiles = localFiles;
-module.exports.nonExisting = nonExisting;
-module.exports.remoteRoot = remoteRoot;
-module.exports.remoteEmptyDir = remoteEmptyDir;
-module.exports.remoteFiles = remoteFiles;
+export {
+  localRoot,
+  localEmptyDir,
+  localFiles,
+  nonExisting,
+  remoteRoot,
+  remoteEmptyDir,
+  remoteFiles
+};

package/.eslintrc.json

@@ -1,34 +0,0 @@
-{
-  "env": {
-    "browser": true,
-    "commonjs": true,
-    "es2021": true
-  },
-  "extends": ["standard"],
-  "overrides": [
-    {
-      "env": {
-        "node": true
-      },
-      "files": [
-        ".eslintrc.{js,cjs}"
-      ],
-      "parserOptions": {
-        "sourceType": "script"
-      }
-    }
-  ],
-  "parserOptions": {
-    "ecmaVersion": "latest"
-  },
-  "rules": {
-    "semi": [
-      "error",
-      "always"
-    ],
-    "quotes": [
-      "error",
-      "double"
-    ]
-  }
-}

package/.github/workflows/npm_publish.yml

@@ -1,22 +0,0 @@
-name: publish npm package
-on:
-  push:
-    tags:
-      - 'v*'
-jobs:
-  test:
-    uses: ./.github/workflows/run_test.yml
-  publish-npm:
-    needs:
-      - test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.npm_token }}

package/test/.eslintrc.json

@@ -1,28 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "mocha": true,
-    "es6": true
-  },
-  "settings": {
-    "node": {
-      "allowModules": [
-        "chai",
-        "chai-fs",
-        "chai-as-promised",
-        "sinon",
-        "sinon-chai",
-        "fs-extra",
-        "rewire"
-      ]
-    }
-  },
-  "plugins": [
-    "chai-expect",
-    "chai-friendly"
-  ],
-  "rules": {
-    "no-unused-expressions": 0,
-    "chai-friendly/no-unused-expressions": 2
-  }
-}