ssh-client-wrapper 2.13.2 → 2.15.0

package/test/sanityCheck.js

@@ -1,106 +0,0 @@
-process.on("unhandledRejection", console.dir);
-
-//setup test framework
-import * as chai from "chai";
-import { expect } from "chai";
-import chaiAsPromised from "chai-as-promised";
-chai.use(chaiAsPromised);
-
-//testee
-import { sanityCheck } from "../lib/util.js";
-
-describe("test for sanityCheck", ()=>{
-  const host = "testHostName";
-  const defaultValues = {
-    ControlPersist: 180,
-    maxRetry: 3,
-    retryDuration: 1000
-  };
-  it("should throw error for empty host", ()=>{
-    expect(sanityCheck.bind(null, { host: "   ", user: "   ", port: 22 })).to.throw(/empty host is not allowed/);
-  });
-  it("should throw error if host is not in argument object", ()=>{
-    expect(sanityCheck.bind(null, { user: "   ", port: 22 })).to.throw(/host is required/);
-  });
-  it("should just remove empty string props", ()=>{
-    expect(sanityCheck({
-      host,
-      user: "   ",
-      port: 22
-    })).to.deep.equal({
-      host,
-      ...defaultValues,
-      port: 22
-    });
-  });
-  it("should remove empty string member in sshOpt", ()=>{
-    expect(sanityCheck({
-      host,
-      sshOpt: ["foo", "  ", "bar"],
-      user: "user",
-      port: 33
-    })).to.deep.equal({
-      host,
-      ...defaultValues,
-      sshOpt: ["foo", "bar"],
-      user: "user",
-      port: 33
-    });
-  });
-  it("should just change type if string value specified for number", ()=>{
-    expect(sanityCheck({
-      host,
-      port: "11",
-      ControlPersist: "22",
-      ConnectTimeout: "33",
-      maxRetry: "44",
-      retryDuration: "55"
-    })).to.deep.equal({
-      host,
-      port: 11,
-      ControlPersist: 22,
-      ConnectTimeout: 33,
-      maxRetry: 44,
-      retryDuration: 55
-    });
-  });
-  it("should remove out of range members", ()=>{
-    expect(sanityCheck({
-      host,
-      ControlPersist: "-1",
-      ConnectTimeout: "-1",
-      maxRetry: "-1",
-      retryDuration: "-1"
-    })).to.deep.equal({
-      host
-    });
-  });
-  it("should just change type if string value specified for boolean member", ()=>{
-    expect(sanityCheck({
-      host,
-      noStrictHostKeyChecking: "true"
-    })).to.deep.equal({
-      host,
-      ...defaultValues,
-      noStrictHostKeyChecking: true
-    });
-  });
-  it("should just change type if number value specified for boolean member", ()=>{
-    expect(sanityCheck({
-      host,
-      noStrictHostKeyChecking: 0
-    })).to.deep.equal({
-      host,
-      ...defaultValues,
-      noStrictHostKeyChecking: false
-    });
-  });
-  it("shold keep addtional properties", ()=>{
-    const testData = {
-      host,
-      hoge: 3,
-      foo: ()=>{}
-    };
-    expect(sanityCheck(testData)).to.deep.equal(testData);
-  });
-});

package/test/sshExec.js

@@ -1,145 +0,0 @@
-import path from "path";
-import { fileURLToPath } from "url";
-
-process.on("unhandledRejection", console.dir);
-Error.traceLimit = 100000;
-
-//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
-import { sshExec, canConnect, disconnect } from "../lib/sshExec.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);
-  beforeEach(async ()=>{
-    sshout.reset();
-    await clearRemoteTestFiles(hostInfo);
-  });
-  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", ()=>{
-    const testText = "hoge";
-    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 ()=>{
-      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 ()=>{
-      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 ()=>{
-      const rt = await sshExec(hostInfo, `./${nonExisting}`);
-      expect(rt).to.equal(127);
-    });
-    it("should be rejected if timeout expired", async ()=>{
-      return expect(sshExec(hostInfo, "sleep 60", 1)).to.be.rejectedWith("watchdog timer expired");
-    });
-  });
-  describe("#canConnect", ()=>{
-    let hostInfo2;
-    beforeEach(async ()=>{
-      await disconnect(hostInfo);
-      hostInfo2 = { ...hostInfo };
-      hostInfo2.masterPty = null;
-    });
-    afterEach(async ()=>{
-      await disconnect(hostInfo2);
-    });
-    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 ()=>{
-      hostInfo2.user = "xxxx";
-      return expect(canConnect(hostInfo2, 2)).to.be.rejected;
-    });
-    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 ()=>{
-      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 ()=>{
-      hostInfo2.host = "192.0.2.1";
-      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 ()=>{
-      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 ()=>{
-      hostInfo2.port = 65536;
-      return expect(canConnect(hostInfo2, 2)).to.be.rejectedWith("invalid port specified 65536");
-    });
-  });
-});

package/test/testUtil/hostInfo.js

@@ -1,9 +0,0 @@
-export default {
-  host: process.env.TEST_HOST || "localhost",
-  user: process.env.TEST_USER || null,
-  port: process.env.TEST_PORT || 22,
-  password: process.env.TEST_PW,
-  passphrase: process.env.TEST_PH,
-  keyFile: process.env.TEST_PRIVATE_KEY,
-  noStrictHostkeyChecking: true
-};

package/test/testUtil/testFiles.js

@@ -1,101 +0,0 @@
-import fs from "fs-extra";
-import path from "path";
-
-import { sshExec } from "../../lib/sshExec.js";
-
-/*
- * test directory tree
- * ${ROOT}
- * +-- huga/ (empty directory)
- * +-- foo
- * +-- bar
- * +-- baz
- * +-- hoge
- *     +-- piyo
- *     +-- puyo
- *     +-- poyo
- *
- * ${ROOT} is "ARssh_testLocalDir" on local side
- * it is ARssh_testLocalDir on remote side
- *
- */
-
-const localRoot = "ARssh_testLocalDir";
-const localEmptyDir = path.join(localRoot, "huga");
-const localFiles = [
-  path.join(localRoot, "foo"),
-  path.join(localRoot, "bar"),
-  path.join(localRoot, "baz"),
-  path.join(localRoot, "hoge", "piyo"),
-  path.join(localRoot, "hoge", "puyo"),
-  path.join(localRoot, "hoge", "poyo")
-];
-
-const remoteRoot = "ARssh_testRemoteDir";
-const remoteEmptyDir = `${remoteRoot}/huga`;
-const remoteFiles = [
-  `${remoteRoot}/foo`,
-  `${remoteRoot}/bar`,
-  `${remoteRoot}/baz`,
-  `${remoteRoot}/hoge/piyo`,
-  `${remoteRoot}/hoge/puyo`,
-  `${remoteRoot}/hoge/poyo`
-];
-const nonExisting = "ARSSH_nonExisting";
-
-/*
- * prepare local files which contain its filename
- */
-/**
- *
- */
-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)=>{
-    promises.push(fs.writeFile(localFile, `${localFile}\n`));
-  });
-  return Promise.all(promises);
-}
-
-/**
- *
- */
-export async function clearLocalTestFiles() {
-  return fs.remove(localRoot);
-}
-
-/**
- *
- * @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)=>{
-    return `${a}echo ${remoteFile} > ${remoteFile};`;
-  }, "");
-  return sshExec(hostInfo, `${script}`);
-}
-
-/**
- *
- * @param hostInfo
- */
-export async function clearRemoteTestFiles(hostInfo) {
-  return sshExec(hostInfo, `rm -fr ${remoteRoot}`);
-}
-
-export {
-  localRoot,
-  localEmptyDir,
-  localFiles,
-  nonExisting,
-  remoteRoot,
-  remoteEmptyDir,
-  remoteFiles
-};

package/test/testUtil/testrc

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