ssh-client-wrapper 2.13.2 → 2.15.0

package/run_test_all.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-function cleanup(){
-  docker compose down
-}
-trap cleanup EXIT
-set -e -o pipefail
-
-./run_test_local.sh keep
-
-docker compose run --build --rm tester
-echo test on latest ubuntu success
-
-docker compose run --build --rm tester-bullseye
-echo test on bullseye success
-
-docker compose run --build --rm tester-buster
-echo test on buster success
-docker compose down

package/run_test_local.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-docker compose up testbed -d
-export TEST_HOST=localhost
-export TEST_USER=testuser
-export TEST_PW=passw0rd
-export TEST_PORT=4100
-ssh-keygen -R '[localhost]:4100'
-
-npm run test
-echo local test success
-if [ x${1} != xkeep ];then
-  docker compose down
-fi

package/test/getSshOption.js

@@ -1,49 +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 { getSshOption } from "../lib/util.js";
-
-describe("test for getSshOption", ()=>{
-  const defaultValues = {
-    host: "testHostName",
-    ControlPersist: 180,
-    maxRetry: 3,
-    retryDuration: 1000
-  };
-  it("should return minimum ssh option array", ()=>{
-    const sshOpts = getSshOption(defaultValues);
-    expect(sshOpts).to.be.an("array");
-    expect(sshOpts).to.have.lengthOf(4);
-    expect(sshOpts[0]).to.equal(defaultValues.host);
-    expect(sshOpts[1]).to.equal("-oControlMaster=auto");
-    expect(sshOpts[2]).to.equal("-oControlPath=~/.ssh/ssh-client-wrapper-%r@%h:%p");
-    expect(sshOpts[3]).to.equal("-oControlPersist=180");
-  });
-  it("should change ControlPath by ControlPersistDir", ()=>{
-    const hostInfo = { ...defaultValues };
-    hostInfo.ControlPersistDir = "/tmp";
-    const sshOpts = getSshOption(hostInfo);
-    expect(sshOpts).to.be.an("array");
-    expect(sshOpts).to.have.lengthOf(4);
-    expect(sshOpts[0]).to.equal(defaultValues.host);
-    expect(sshOpts[1]).to.equal("-oControlMaster=auto");
-    expect(sshOpts[2]).to.equal("-oControlPath=/tmp/ssh-client-wrapper-%r@%h:%p");
-    expect(sshOpts[3]).to.equal("-oControlPersist=180");
-  });
-  it("should change ControlPath by Environment variable", ()=>{
-    process.env.SSH_CONTROL_PERSIST_DIR = "/tmp";
-    const sshOpts = getSshOption(defaultValues);
-    expect(sshOpts).to.be.an("array");
-    expect(sshOpts).to.have.lengthOf(4);
-    expect(sshOpts[0]).to.equal(defaultValues.host);
-    expect(sshOpts[1]).to.equal("-oControlMaster=auto");
-    expect(sshOpts[2]).to.equal("-oControlPath=/tmp/ssh-client-wrapper-%r@%h:%p");
-    expect(sshOpts[3]).to.equal("-oControlPersist=180");
-  });
-});

package/test/interface.js

@@ -1,182 +0,0 @@
-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);
-
-//testee
-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();
-
-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(()=>{
-        new SshClientWrapper({}, deps);
-      }).to.throw("host is required");
-      expect(()=>{
-        new SshClientWrapper({ host: "" }, deps);
-      }).to.throw("empty host is not allowed");
-    });
-    it("should successfully instanciate only with host prop", ()=>{
-      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", ()=>{
-    let ssh;
-    const hostInfoOrg = {
-      host: "hoge",
-      ControlPersist: 180,
-      maxRetry: 3,
-      retryDuration: 1000
-    };
-    const hostInfo = { ...hostInfoOrg, masterPty: null, rsyncVersion: null };
-    beforeEach(()=>{
-      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", ()=>{
-        ssh.exec("ls");
-        expect(sshExec).to.be.calledWith(hostInfo, "ls", 0, null);
-      });
-      it("should call sshExec with cmd and timeout", ()=>{
-        ssh.exec("ls", 10);
-        expect(sshExec).to.be.calledWith(hostInfo, "ls", 10, null);
-      });
-      it("should call sshExec with cmd, timeout and call back function", ()=>{
-        const cb = ()=>{};
-        ssh.exec("ls", 10, cb);
-        expect(sshExec).to.be.calledWith(hostInfo, "ls", 10, cb);
-      });
-      it("should reject if cmd is not string (number)", ()=>{
-        return expect(ssh.exec(0)).to.be.rejectedWith("cmd must be string");
-      });
-      it("should reject if cmd is not string (null)", ()=>{
-        return expect(ssh.exec(null)).to.be.rejectedWith("cmd must be string");
-      });
-      it("should reject if cmd is empty string", ()=>{
-        return expect(ssh.exec("")).to.be.rejectedWith("cmd must be string");
-      });
-    });
-    describe("test for ls", ()=>{
-      it("should call ls without timeout", ()=>{
-        ssh.ls("hoge");
-        expect(sshExec).to.be.calledWith(hostInfo, "ls  hoge", 0);
-      });
-      it("should call ls with option", ()=>{
-        ssh.ls("hoge", ["-l", "-r", "-t"]);
-        expect(sshExec).to.be.calledWith(hostInfo, "ls -l -r -t hoge", 0);
-      });
-      it("should call ls with option and timeout", ()=>{
-        ssh.ls("hoge", ["-l", "-r", "-t"], 10);
-        expect(sshExec).to.be.calledWith(hostInfo, "ls -l -r -t hoge", 10);
-      });
-    });
-    describe("test for send", ()=>{
-      it("should call send with src and dst", ()=>{
-        ssh.send(["src"], "dst");
-        expect(send).to.be.calledWith(hostInfo, ["src"], "dst", [], 0);
-      });
-      it("should call send with src, dst, and opt", ()=>{
-        ssh.send(["src"], "dst", ["--dry-run", "--delete"]);
-        expect(send).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 0);
-      });
-      it("should call send with src, dst, opt, and timeout", ()=>{
-        ssh.send(["src"], "dst", ["--dry-run", "--delete"], 10);
-        expect(send).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 10);
-      });
-      it("should be rejected if src is not array of string", ()=>{
-        return expect(ssh.send(1)).to.be.rejectedWith("src must be array of string");
-      });
-      it("should be rejected if src has only empty string element", ()=>{
-        return expect(ssh.send(["", ""])).to.be.rejectedWith("src must contain non-empty string");
-      });
-      it("should be rejected if src has only empty string element", ()=>{
-        return expect(ssh.send([""])).to.be.rejectedWith("src must contain non-empty string");
-      });
-      it("should be called if src includes empty string ", ()=>{
-        ssh.send(["src", ""], "dst");
-        expect(send).to.be.calledWith(hostInfo, ["src", ""], "dst", [], 0);
-      });
-      it("should be rejected if dst is not string", ()=>{
-        return expect(ssh.send(["src"], 0)).to.be.rejectedWith("dst must be string");
-      });
-      it("should be rejected if dst is empty string", ()=>{
-        return expect(ssh.send(["src"], "")).to.be.rejectedWith("dst must be non-empty string");
-      });
-      it("should be rejected if opt is not array of string", ()=>{
-        return expect(ssh.send(["src"], "dst", [null])).to.be.rejectedWith("opt must be array of string");
-      });
-    });
-    describe("test for recv", ()=>{
-      it("should call recv with src and dst", ()=>{
-        ssh.recv(["src"], "dst");
-        expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", [], 0);
-      });
-      it("should call recv with src, dst, and opt", ()=>{
-        ssh.recv(["src"], "dst", ["--dry-run", "--delete"]);
-        expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 0);
-      });
-      it("should call recv with src, dst, opt, and timeout", ()=>{
-        ssh.recv(["src"], "dst", ["--dry-run", "--delete"], 10);
-        expect(recv).to.be.calledWith(hostInfo, ["src"], "dst", ["--dry-run", "--delete"], 10);
-      });
-      it("should be rejected if src is not array of string", ()=>{
-        return expect(ssh.recv(1)).to.be.rejectedWith("src must be array of string");
-      });
-      it("should be rejected if src has only empty string element", ()=>{
-        return expect(ssh.recv(["", ""])).to.be.rejectedWith("src must contain non-empty string");
-      });
-      it("should be rejected if src has only empty string element", ()=>{
-        return expect(ssh.recv([""])).to.be.rejectedWith("src must contain non-empty string");
-      });
-      it("should be called if src includes empty string ", ()=>{
-        ssh.recv(["src", ""], "dst");
-        expect(recv).to.be.calledWith(hostInfo, ["src", ""], "dst", [], 0);
-      });
-      it("should be rejected if dst is not string", ()=>{
-        return expect(ssh.recv(["src"], 0)).to.be.rejectedWith("dst must be string");
-      });
-      it("should be rejected if dst is empty string", ()=>{
-        return expect(ssh.recv(["src"], "")).to.be.rejectedWith("dst must be non-empty string");
-      });
-      it("should be rejected if opt is not array of string", ()=>{
-        return expect(ssh.recv(["src"], "dst", [null])).to.be.rejectedWith("opt must be array of string");
-      });
-    });
-  });
-});

package/test/rsyncExec.js

@@ -1,406 +0,0 @@
-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
- * (1) enable folloing line
- *          const debug = require("debug");
- * (2) insert this line into the beginning of it()
- *         debug.enable("ssh*");
- * (3) insert this line into the end of it()
- *         debug.disable();
- */
-
-process.on("unhandledRejection", console.dir);
-Error.traceLimit = 100000;
-
-//setup test framework
-import * as chai from "chai";
-import { expect } from "chai";
-import chaiAsPromised from "chai-as-promised";
-chai.use(chaiAsPromised);
-
-//testee
-import { checkRsyncVersion, send, recv } from "../lib/rsyncExec.js";
-
-//test helpers
-import { sshExec, disconnect } from "../lib/sshExec.js";
-import hostInfo from "./testUtil/hostInfo.js";
-import {
-  clearLocalTestFiles,
-  clearRemoteTestFiles,
-  createLocalFiles,
-  localRoot,
-  localEmptyDir,
-  localFiles,
-  createRemoteFiles,
-  remoteRoot,
-  remoteEmptyDir,
-  remoteFiles
-} from "./testUtil/testFiles.js";
-
-const formatLsOutput = (array)=>{
-  const rt = [];
-  for (const e of array) {
-    rt.push(...e.split("\n"));
-  }
-  return rt.filter((e)=>{
-    return e !== "";
-  });
-};
-
-//actual test start from here
-describe("test checkRsyncVersion", async ()=>{
-  const { major, minor, patch } = await checkRsyncVersion(1);
-  const versionString = `${major}.${minor}.${patch}`;
-  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);
-  const rt = [];
-  const output = (data)=>{
-    rt.push(data);
-  };
-  let remoteHome;
-  before(async ()=>{
-    await sshExec(hostInfo, "pwd", 0, (data)=>{
-      remoteHome = data.trim();
-    });
-  });
-  beforeEach(async ()=>{
-    await clearRemoteTestFiles(hostInfo);
-    await createRemoteFiles(hostInfo);
-    await clearLocalTestFiles();
-    await createLocalFiles();
-    rt.splice(0, rt.length);
-  });
-  after(async ()=>{
-    if (!process.env.TEST_KEEP_FILES) {
-      await clearRemoteTestFiles(hostInfo);
-      await clearLocalTestFiles();
-    }
-    await disconnect(hostInfo);
-  });
-  describe("#send", async ()=>{
-    describe("send single file", ()=>{
-      it("should accept relative src file and relative dst dir name", async ()=>{
-        await send(hostInfo, [localFiles[0]], remoteEmptyDir, [], 0);
-
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo"]);
-      });
-      it("should accept absolute src file and relative dst dir name", async ()=>{
-        await send(hostInfo, [path.resolve(localFiles[3])], remoteEmptyDir, [], 0);
-
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["piyo"]);
-      });
-      it("should accept relative src file and absolute dst dir name", async ()=>{
-        await send(hostInfo, [localFiles[0]], `${path.posix.join(remoteHome, remoteEmptyDir)}/`, [], 0);
-
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo"]);
-      });
-      it("should accept absolute src file and absolute dst dir name", async ()=>{
-        await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
-
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo"]);
-      });
-      it("should accept relative src file and relative dst file name", async ()=>{
-        await send(hostInfo, [localFiles[0]], path.posix.join(remoteEmptyDir, "hoge"), [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e)=>{
-          return path.posix.basename(e);
-        }))).to.have.members(["hoge"]);
-      });
-      it("should accept absolute src file and relative dst file name", async ()=>{
-        await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteEmptyDir, "hoge"), [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e)=>{
-          return path.posix.basename(e);
-        }))).to.have.members(["hoge"]);
-      });
-      it("should accept relative src file and absolute dst file name", async ()=>{
-        await send(hostInfo, [localFiles[0]], path.posix.join(remoteHome, remoteEmptyDir, "hoge"), [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e)=>{
-          return path.posix.basename(e);
-        }))).to.have.members(["hoge"]);
-      });
-      it("should accept absolute src file and absolute dst file name", async ()=>{
-        await send(hostInfo, [path.resolve(localFiles[0])], path.posix.join(remoteHome, remoteEmptyDir, "hoge"), [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt.map((e)=>{
-          return path.posix.basename(e);
-        }))).to.have.members(["hoge"]);
-      });
-
-      it("should overwrite existing file", async ()=>{
-        const target = path.posix.join(remoteEmptyDir, "hoge");
-        await send(hostInfo, [localFiles[0]], target, [], 0);
-        await sshExec(hostInfo, `ls ${target}`, 0, output);
-        expect(formatLsOutput(rt.map((e)=>{
-          return path.posix.basename(e);
-        }))).to.have.members(["hoge"]);
-        rt.splice(0, rt.length);
-
-        const time = new Date();
-        time.setMinutes(time.getMinutes() + 3);
-        await fs.utimes(localFiles[1], time, time);
-        await send(hostInfo, [localFiles[1]], target, [], 0);
-        await sshExec(hostInfo, `ls ${target}`, 0, output);
-        expect(formatLsOutput(rt.map((e)=>{
-          return path.posix.basename(e);
-        }))).to.have.members(["hoge"]);
-
-        rt.splice(0, rt.length);
-        await sshExec(hostInfo, `cat ${target}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["ARssh_testLocalDir/bar"]);
-      });
-    });
-    describe("send directory tree", ()=>{
-      it("should accept relative src dirname and relative dst dirname", async ()=>{
-        await send(hostInfo, [localRoot], remoteEmptyDir, [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-
-        rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should accept absolute src dirname and relative dst dirname", async ()=>{
-        await send(hostInfo, [path.resolve(localRoot)], remoteEmptyDir, [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-
-        rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should accept relative src dirname and absolute dst dirname", async ()=>{
-        await send(hostInfo, [localRoot], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-
-        rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should accept absolute src dirname and absolute dst dirname", async ()=>{
-        await send(hostInfo, [path.resolve(localRoot)], path.posix.join(remoteHome, remoteEmptyDir), [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-
-        rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      //only option need special treatment in rsyncExec. it's hard to set in WHEEL
-      it.skip("[not implemented] should send directory tree if only filter matched", async ()=>{
-        await send(hostInfo, [localRoot], remoteEmptyDir, [`--include=${localRoot}`, `--include=${localRoot}/ba*`, `--include=${localRoot}/hoge/*`, "--exclude=*"], [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["hoge", "bar", "baz"]);
-
-        rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should send directory tree if exclude filter not matched", async ()=>{
-        await send(hostInfo, [localRoot], remoteEmptyDir, ["--exclude=ba*", "--exclude=hoge*}"], [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["foo", "hoge", "huga"]);
-      });
-      it.skip("[not implemented] should send directory tree if only filter matched but exclude filter not matched", async ()=>{
-        await send(hostInfo, [localRoot], remoteEmptyDir, "*/{ba*,hoge/*}", "**/poyo", [], 0);
-
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot)}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["hoge", "bar", "baz"]);
-
-        rt.splice(0, rt.length);
-        await sshExec(hostInfo, `ls ${path.posix.join(remoteEmptyDir, localRoot, "hoge")}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["piyo", "puyo"]);
-      });
-      it("shoud not send empty directory with -m option", async ()=>{
-        await send(hostInfo, [localEmptyDir], remoteEmptyDir, ["-m"], [], 0);
-
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
-        expect(rt).to.have.lengthOf(0);
-      });
-      it("should send files which match glob pattern", async ()=>{
-        await send(hostInfo, [path.join(localRoot, "b*")], remoteEmptyDir, [], 0);
-
-        await sshExec(hostInfo, `ls ${remoteEmptyDir}`, 0, output);
-        expect(formatLsOutput(rt)).to.have.members(["bar", "baz"]);
-      });
-    });
-    describe("error case", ()=>{
-      it("should not send directory to existing file path", ()=>{
-        return expect(send(hostInfo, [localRoot], path.posix.join(remoteRoot, "foo"), [], 0)).to.be.rejected;
-      });
-    });
-  });
-  describe("#recv", async ()=>{
-    describe("recieve single file", ()=>{
-      it("should accept relative src file and relative dst dir name", async ()=>{
-        await recv(hostInfo, [remoteFiles[3]], localEmptyDir, [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["piyo"]);
-      });
-      it("should accept absolute src file and relative dst dir name", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[3])], localEmptyDir, [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["piyo"]);
-      });
-      it("should accept relative src file and absolute dst dir name", async ()=>{
-        await recv(hostInfo, [remoteFiles[3]], path.resolve(localEmptyDir), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["piyo"]);
-      });
-      it("should accept absolute src file and absolute dst dir name", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[3])], path.resolve(localEmptyDir), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["piyo"]);
-      });
-      it("should accept relative src file and relative dst file name", async ()=>{
-        await recv(hostInfo, [remoteFiles[0]], path.join(localEmptyDir, "hoge"), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["hoge"]);
-      });
-      it("should accept absolute src file and relative dst file name", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[0])], path.join(localEmptyDir, "hoge"), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["hoge"]);
-      });
-      it("should accept relative src file and absolute dst file name", async ()=>{
-        await recv(hostInfo, [remoteFiles[0]], path.resolve(localEmptyDir, "hoge"), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["hoge"]);
-      });
-      it("should accept absolute src file and absolute dst file name", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteHome, remoteFiles[0])], path.resolve(localEmptyDir, "hoge"), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["hoge"]);
-      });
-      it("should accept glob pattern as src", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteRoot, "b*")], path.resolve(localEmptyDir), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["bar", "baz"]);
-      });
-      it("should accept glob pattern as src", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteRoot, "*/p[iu]yo")], path.resolve(localEmptyDir), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["piyo", "puyo"]);
-      });
-      it.skip("[temporarily disabled number 23 was thrown] should accept glob pattern as src", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteRoot, "hoge/p[iu]yo"), path.posix.join(remoteRoot, "foo")], path.resolve(localEmptyDir), [], 0);
-
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["piyo", "puyo", "foo"]);
-      });
-    });
-    describe("recieve directory tree", ()=>{
-      it("should get directory tree which match specified glob", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteRoot, "?o*")], localEmptyDir, [], 0);
-
-        let rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["foo", "hoge"]);
-        rt2 = await fs.readdir(path.join(localEmptyDir, "hoge"));
-        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should accept relative src dirname and relative dst dirname", async ()=>{
-        await recv(hostInfo, [remoteRoot], localEmptyDir, [], 0);
-
-        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
-        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should accept absolute src dirname and relative dst dirname", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], localEmptyDir, [], 0);
-
-        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
-        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should accept relative src dirname and absolute dst dirname", async ()=>{
-        await recv(hostInfo, [remoteRoot], path.resolve(localEmptyDir), [], 0);
-
-        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
-        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should accept absolute src dirname and absolute dst dirname", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteHome, remoteRoot)], path.resolve(localEmptyDir), [], 0);
-
-        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "bar", "baz", "hoge", "huga"]);
-        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
-        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it.skip("[not implemented] should recv files which matches only filter", async ()=>{
-        await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}", [], 0);
-
-        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["bar", "baz", "hoge"]);
-        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
-        expect(rt2).to.have.members(["piyo", "puyo", "poyo"]);
-      });
-      it("should not recv files which matches exclude filter", async ()=>{
-        await recv(hostInfo, [remoteRoot], localEmptyDir, ["--exclude=*/ba*", "--exclude=hoge"], [], 0);
-
-        const rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["foo", "huga"]);
-      });
-      it.skip("[not implemented] should recv files which matches only filter but should not recv which matches exclude filter", async ()=>{
-        await recv(hostInfo, [remoteRoot], localEmptyDir, "*/{ba*,hoge/*}", "**/piyo", [], 0);
-
-        let rt2 = await fs.readdir(path.posix.join(localEmptyDir, remoteRoot));
-        expect(rt2).to.have.members(["bar", "baz", "hoge"]);
-        rt2 = await fs.readdir(path.join(localEmptyDir, remoteRoot, "hoge"));
-        expect(rt2).to.have.members(["puyo", "poyo"]);
-      });
-    });
-    describe("degradation check", ()=>{
-      it("should recieve multiple files from remote machine", async ()=>{
-        await recv(hostInfo, [path.posix.join(remoteRoot, "foo"),
-          path.posix.join(remoteRoot, "bar"), path.posix.join(remoteRoot, "baz")], localEmptyDir, [], 0);
-        const rt2 = await fs.readdir(localEmptyDir);
-        expect(rt2).to.have.members(["foo", "bar", "baz"]);
-      });
-    });
-    describe("error case", ()=>{
-      it("should not send directory to existing file path", ()=>{
-        return expect(recv(hostInfo, [remoteRoot], localFiles[0], [], 0)).to.be.rejected;
-      });
-    });
-  });
-});