ssh-client-wrapper 2.10.2 → 2.12.4

package/test/sshExec.js

@@ -1,10 +1,10 @@
 "use strict";
 const path = require("path");
 
-process.on("unhandledRejection", console.dir); // eslint-disable-line no-console
+process.on("unhandledRejection", console.dir); //eslint-disable-line no-console
 Error.traceLimit = 100000;
 
-// setup test framework
+//setup test framework
 const chai = require("chai");
 const { expect } = require("chai");
 const sinon = require("sinon");
@@ -13,127 +13,129 @@ chai.use(require("chai-as-promised"));
 
 const sshout = sinon.stub();
 
-// testee
-const { sshExec, canConnect, disconnect, ls } = require("../lib/sshExec.js");
+//testee
+const { sshExec, canConnect, disconnect } = require("../lib/sshExec.js");
 
-// test helpers
+//test helpers
 const hostInfo = require("./testUtil/hostInfo.js");
-const { clearRemoteTestFiles, clearLocalTestFiles, createRemoteFiles, nonExisting, remoteRoot, remoteEmptyDir } = require("./testUtil/testFiles.js");
+const { clearRemoteTestFiles, clearLocalTestFiles, nonExisting } = require("./testUtil/testFiles.js");
+const { send } = require("../lib/rsyncExec.js");
 
 describe("test for ssh execution", function () {
-  this.timeout(65000);// eslint-disable-line no-invalid-this
-  beforeEach(async () => {
+  const rcfilePath = "/home/testuser/testrc";
+  this.timeout(65000);//eslint-disable-line no-invalid-this
+  beforeEach(async ()=>{
     sshout.reset();
     await clearRemoteTestFiles(hostInfo);
   });
-  after(async () => {
+  before(async ()=>{
+    await send(hostInfo, [path.resolve(__dirname, "./testUtil/testrc")], rcfilePath, [], 0);
+  });
+  after(async ()=>{
     if (!process.env.TEST_KEEP_FILES) {
       await clearRemoteTestFiles(hostInfo);
       await clearLocalTestFiles();
+      await sshExec(hostInfo, `rm ${rcfilePath}`);
     }
     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/);
     });
-    // please note that exec() resolves with non-zero value
-    // (126 permisssion 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 () => {
+    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 ()=>{
+      hostInfo.prependCmd = "echo foo";
+      const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout, null);
+      expect(rt).to.equal(0);
+      expect(sshout).to.be.calledOnce;
+      expect(sshout).to.be.calledWithMatch(/^foo\nhoge\n/);
+      delete hostInfo.prependCmd;
+    });
+    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 ()=>{
+      hostInfo.rcfile = rcfilePath;
+      const rt = await sshExec(hostInfo, `echo ${testText}`, 0, sshout, null);
+      expect(rt).to.equal(0);
+      expect(sshout).to.be.calledOnce;
+      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 ()=>{
       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/testFiles.js

@@ -47,33 +47,47 @@ const nonExisting = "ARSSH_nonExisting";
 /*
  * prepare local files which contain its filename
  */
-async function createLocalFiles () {
+/**
+ *
+ */
+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 () {
+/**
+ *
+ */
+async function clearLocalTestFiles() {
   return fs.remove(localRoot);
 }
 
-async function createRemoteFiles (hostInfo) {
-  // create remote files
+/**
+ *
+ * @param hostInfo
+ */
+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
+ */
+async function clearRemoteTestFiles(hostInfo) {
   return sshExec(hostInfo, `rm -fr ${remoteRoot}`);
 }
 

package/test/testUtil/testrc

@@ -0,0 +1 @@
+echo this is test rcfile