ssh2-sftp-client 2.4.3 → 2.5.0

package/test/hooks/checksum-hooks.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const {join} = require('path');
+const fs = require('fs');
+
+function checksumCleanup(client, sftpUrl, localUrl) {
+  return client
+    .delete(join(sftpUrl, 'checksum-file1.txt'))
+    .then(() => {
+      return client.delete(join(sftpUrl, 'checksum-file2.txt.gz'));
+    })
+    .then(() => {
+      fs.unlinkSync(join(localUrl, 'checksum-file1.txt'));
+      fs.unlinkSync(join(localUrl, 'checksum-file2.txt.gz'));
+      return true;
+    })
+    .catch(err => {
+      throw new Error(err.message);
+    });
+}
+
+module.exports = {
+  checksumCleanup
+};

package/test/hooks/chmod-hooks.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const {join} = require('path');
+
+function chmodSetup(client, sftpUrl) {
+  return client
+    .put(Buffer.from('hello'), join(sftpUrl, 'mocha-chmod.txt'), {
+      encoding: 'utf8'
+    })
+    .catch(err => {
+      throw new Error(`Chmod setup hook error: ${err.message}`);
+    });
+}
+
+function chmodCleanup(client, sftpUrl) {
+  return client.delete(join(sftpUrl, 'mocha-chmod.txt')).catch(err => {
+    throw new Error(`Chmod cleanup hook error: ${err.message}`);
+  });
+}
+
+module.exports = {
+  chmodSetup,
+  chmodCleanup
+};

package/test/hooks/delete-hooks.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const {join} = require('path');
+
+function deleteSetup(client, sftpUrl) {
+  return client
+    .put(Buffer.from('hello'), join(sftpUrl, 'mocha-delete.md'), {
+      encoding: 'utf8'
+    })
+    .then(() => {
+      return client.put(
+        Buffer.from('promise'),
+        join(sftpUrl, 'mocha-delete-promise.md'),
+        {encoding: 'utf8'}
+      );
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Delete setup hook error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  deleteSetup
+};

package/test/hooks/exist-hooks.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const {join} = require('path');
+
+function existSetup(client, sftpUrl, localUrl) {
+  return client
+    .mkdir(join(sftpUrl, 'exist-dir'))
+    .then(() => {
+      return client.fastPut(
+        join(localUrl, 'test-file1.txt'),
+        join(sftpUrl, 'exist-file.txt')
+      );
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Exist method test setup hook failure: ${err.message}`);
+    });
+}
+
+function existCleanup(client, sftpUrl) {
+  return client
+    .delete(join(sftpUrl, 'exist-file.txt'))
+    .then(() => {
+      return client.rmdir(join(sftpUrl, 'exist-dir'));
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Exist method test clenaup hook failed: ${err.message}`);
+    });
+}
+
+module.exports = {
+  existSetup,
+  existCleanup
+};

package/test/hooks/fastGet-hooks.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const {join} = require('path');
+const fs = require('fs');
+
+function fastGetSetup(client, sftpUrl, localUrl) {
+  return client
+    .put(Buffer.from('fast get'), join(sftpUrl, 'mocha-fastget1.md'), {
+      encoding: 'utf8'
+    })
+    .then(() => {
+      return client.fastPut(
+        join(localUrl, 'test-file1.txt'),
+        join(sftpUrl, 'mocha-fastget2.txt'),
+        {encoding: 'utf8'}
+      );
+    })
+    .then(() => {
+      return client.fastPut(
+        join(localUrl, 'test-file2.txt.gz'),
+        join(sftpUrl, 'mocha-fastget3.txt.gz'),
+        {encoding: null}
+      );
+    })
+    .then(() => {
+      return fs.mkdirSync(join(localUrl, 'fastGet'));
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`FastGet test setup error: ${err.message}`);
+    });
+}
+
+function fastGetCleanup(client, sftpUrl, localUrl) {
+  let localDir = join(localUrl, 'fastGet');
+  return client
+    .delete(join(sftpUrl, 'mocha-fastget1.md'))
+    .then(() => {
+      return client.delete(join(sftpUrl, 'mocha-fastget2.txt'));
+    })
+    .then(() => {
+      return client.delete(join(sftpUrl, 'mocha-fastget3.txt.gz'));
+    })
+    .then(() => {
+      fs.unlinkSync(join(localDir, 'local1.md'));
+      fs.unlinkSync(join(localDir, 'local2.txt'));
+      fs.unlinkSync(join(localDir, 'local3.txt.gz'));
+      return fs.rmdirSync(localDir);
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`FastGet test cleanup hook error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  fastGetSetup,
+  fastGetCleanup
+};

package/test/hooks/fastPut-hooks.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const {join} = require('path');
+
+function fastPutSetup(client, sftpUrl) {
+  return client
+    .put(Buffer.from('fast put'), join(sftpUrl, 'mocha-fastput.md'))
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`FastPut setup hook error: ${err.message}`);
+    });
+}
+
+function fastPutCleanup(client, sftpUrl) {
+  return client
+    .delete(join(sftpUrl, 'remote2.md.gz'))
+    .then(() => {
+      return client.delete(join(sftpUrl, 'remote.md'));
+    })
+    .then(() => {
+      return client.delete(join(sftpUrl, 'mocha-fastput.md'));
+    })
+    .catch(err => {
+      throw new Error(`FastPut cleanup hook error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  fastPutSetup,
+  fastPutCleanup
+};

package/test/hooks/get-hooks.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const {join} = require('path');
+const fs = require('fs');
+
+function getSetup(client, sftpUrl, localUrl) {
+  return client
+    .put(Buffer.from('hello'), join(sftpUrl, 'mocha-file.md'), {
+      encoding: 'utf8'
+    })
+    .then(() => {
+      return client.fastPut(
+        join(localUrl, 'test-file1.txt'),
+        join(sftpUrl, 'large-file1.txt'),
+        {encoding: 'utf8'}
+      );
+    })
+    .then(() => {
+      return client.fastPut(
+        join(localUrl, 'test-file2.txt.gz'),
+        join(sftpUrl, 'gzipped-file.txt.gz')
+      );
+    })
+    .catch(err => {
+      throw new Error(`Get setup hook error: ${err.message}`);
+    });
+}
+
+function getCleanup(client, sftpUrl, localUrl) {
+  return client
+    .delete(join(sftpUrl, 'mocha-file.md'))
+    .then(() => {
+      return client.delete(join(sftpUrl, 'large-file1.txt'));
+    })
+    .then(() => {
+      return client.delete(join(sftpUrl, 'gzipped-file.txt.gz'));
+    })
+    .then(() => {
+      fs.unlinkSync(join(localUrl, 'local-large-file.txt'));
+      fs.unlinkSync(join(localUrl, 'local-gizipped-file.txt.gz'));
+      fs.unlinkSync(join(localUrl, 'local-gzipped-file.txt'));
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Get cleanup hook error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  getSetup,
+  getCleanup
+};

package/test/hooks/global-hooks.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const dotenvPath = __dirname + '/../../.env';
+
+require('dotenv').config({path: dotenvPath});
+
+const Client = require('../../src/index.js');
+const {join} = require('path');
+
+// use your test ssh server config
+const config = {
+  host: process.env['SFTP_SERVER'],
+  username: process.env['SFTP_USER'],
+  password: process.env['SFTP_PASSWORD'],
+  port: process.env['SFTP_PORT'] || 22
+};
+
+const testEnv = {
+  sftp: new Client(),
+  hookSftp: new Client(),
+  localUrl: join(__dirname, '../testData'),
+  sftpUrl: process.env['SFTP_URL']
+};
+
+let initialised = false;
+
+function setup() {
+  if (!initialised) {
+    return testEnv.sftp
+      .connect(config, 'once')
+      .then(() => {
+        return testEnv.hookSftp.connect(config, 'once');
+      })
+      .then(() => {
+        initialised = true;
+        return testEnv;
+      })
+      .catch(err => {
+        throw new Error(`Global test setup failed: ${err.message}`);
+      });
+  }
+  return Promise.resolve(testEnv);
+}
+
+function closeDown() {
+  if (initialised) {
+    return testEnv.sftp
+      .end()
+      .then(() => {
+        return testEnv.hookSftp.end();
+      })
+      .then(() => {
+        initialised = false;
+        return true;
+      })
+      .catch(err => {
+        throw new Error(`Global test cleanup failed: ${err.message}`);
+      });
+  }
+  return Promise.resolve(true);
+}
+
+module.exports = {
+  setup,
+  closeDown
+};

package/test/hooks/list-hooks.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const {join} = require('path');
+
+function listSetup(client, sftpUrl, localUrl) {
+  return client
+    .mkdir(join(sftpUrl, 'mocha-list/dir1'), true)
+    .then(() => {
+      return client.mkdir(join(sftpUrl, 'mocha-list/dir2/sub1'), true);
+    })
+    .then(() => {
+      return client.mkdir(join(sftpUrl, 'mocha-list/empty'), true);
+    })
+    .then(() => {
+      return client.put(
+        Buffer.from('hello file1'),
+        join(sftpUrl, 'mocha-list/file1.html'),
+        {encoding: 'utf8'}
+      );
+    })
+    .then(() => {
+      return client.put(
+        Buffer.from('hello file2'),
+        join(sftpUrl, 'mocha-list/file2.md'),
+        {encoding: 'utf8'}
+      );
+    })
+    .then(() => {
+      return client.fastPut(
+        join(localUrl, 'test-file1.txt'),
+        join(sftpUrl, 'mocha-list/test-file1.txt'),
+        {encoding: 'utf8'}
+      );
+    })
+    .then(() => {
+      return client.fastPut(
+        join(localUrl, 'test-file2.txt.gz'),
+        join(sftpUrl, 'mocha-list/test-file2.txt.gz')
+      );
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`List method setup hook error: ${err.message}`);
+    });
+}
+
+function listCleanup(client, sftpUrl) {
+  return client
+    .rmdir(join(sftpUrl, 'mocha-list'), true)
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`List method cleanup error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  listSetup,
+  listCleanup
+};

package/test/hooks/mkdir-hooks.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const {join} = require('path');
+
+function mkdirCleanup(client, sftpUrl) {
+  return client
+    .rmdir(join(sftpUrl, 'mocha'), true)
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Mkdir test cleanup hook failure: ${err.message}`);
+    });
+}
+
+module.exports = {
+  mkdirCleanup
+};

package/test/hooks/put-hooks.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const {join} = require('path');
+
+function putCleanup(client, sftpUrl) {
+  return client
+    .delete(join(sftpUrl, 'mocha-put-string.md'))
+    .then(() => {
+      return client.delete(join(sftpUrl, 'mocha-put-buffer.md'));
+    })
+    .then(() => {
+      return client.delete(join(sftpUrl, 'mocha-put-stream.md'));
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Put cleanup hook error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  putCleanup
+};

package/test/hooks/rename-hooks.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const {join} = require('path');
+
+function renameSetup(client, sftpUrl) {
+  return client
+    .put(Buffer.from('hello'), join(sftpUrl, 'mocha-rename.md'), {
+      encoding: 'utf8'
+    })
+    .then(() => {
+      return client.put(
+        Buffer.from('conflict file'),
+        join(sftpUrl, 'mocha-conflict.md'),
+        {encoding: 'utf8'}
+      );
+    })
+    .catch(err => {
+      throw new Error(`Rename setup hook error: ${err.message}`);
+    });
+}
+
+function renameCleanup(client, sftpUrl) {
+  return client
+    .delete(join(sftpUrl, 'mocha-rename-new.md'))
+    .then(() => {
+      return client.delete(join(sftpUrl, 'mocha-conflict.md'));
+    })
+    .catch(err => {
+      throw new Error(`Rename cleanup hook error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  renameSetup,
+  renameCleanup
+};

package/test/hooks/rmdir-hooks.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const {join} = require('path');
+
+function rmdirSetup(client, sftpUrl) {
+  return client
+    .mkdir(join(sftpUrl, 'mocha'))
+    .then(() => {
+      return client.mkdir(join(sftpUrl, 'mocha-rmdir/dir1'), true);
+    })
+    .then(() => {
+      return client.mkdir(join(sftpUrl, 'mocha-rmdir/dir2'), true);
+    })
+    .then(() => {
+      return client.mkdir(join(sftpUrl, 'mocha-rmdir/dir3/subdir'), true);
+    })
+    .then(() => {
+      return client.put(
+        Buffer.from('hello'),
+        join(sftpUrl, 'mocha-rmdir/file1.md'),
+        {encoding: 'utf8'}
+      );
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Rmdir setup hook error: ${err.message}`);
+    });
+}
+
+module.exports = {
+  rmdirSetup
+};

package/test/hooks/stat-hooks.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const {join} = require('path');
+
+function statSetup(client, sftpUrl) {
+  return client
+    .put(Buffer.from('hello'), join(sftpUrl, 'mocha-stat.md'), {
+      encoding: 'utf8',
+      mode: 0o777
+    })
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Stat test setup hook failure: ${err.message}`);
+    });
+}
+
+function statCleanup(client, sftpUrl) {
+  return client
+    .delete(join(sftpUrl, 'mocha-stat.md'))
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(`Stat test cleanup hook failed: ${err.message}`);
+    });
+}
+
+module.exports = {
+  statSetup,
+  statCleanup
+};

package/test/mocha.opts

@@ -1 +1 @@
--t 5000
+-t 0

package/test/put.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const chai = require('chai');
+const expect = chai.expect;
+const chaiSubset = require('chai-subset');
+const chaiAsPromised = require('chai-as-promised');
+const {join} = require('path');
+const stream = require('stream');
+const {setup, closeDown} = require('./hooks/global-hooks');
+const pHooks = require('./hooks/put-hooks');
+
+chai.use(chaiSubset);
+chai.use(chaiAsPromised);
+
+let hookSftp, sftp, sftpUrl, localUrl;
+
+before('Global setup', function() {
+  return setup()
+    .then(testEnv => {
+      hookSftp = testEnv.hookSftp;
+      sftp = testEnv.sftp;
+      sftpUrl = testEnv.sftpUrl;
+      localUrl = testEnv.localUrl;
+      return true;
+    })
+    .catch(err => {
+      throw new Error(err.message);
+    });
+});
+
+after('Global shutdown', function() {
+  return closeDown()
+    .then(() => {
+      return true;
+    })
+    .catch(err => {
+      throw new Error(err.message);
+    });
+});
+
+describe('Put method tests', function() {
+  after('Put cleanup hook', function() {
+    return pHooks.putCleanup(hookSftp, sftpUrl).catch(err => {
+      throw new Error(err.message);
+    });
+  });
+
+  it('Put should return a promise', function() {
+    return expect(
+      sftp.put(Buffer.from('blah'), join(sftpUrl, 'mocha-put-buffer.md'))
+    ).to.be.a('promise');
+  });
+
+  it('Put large text file', function() {
+    return sftp
+      .put(
+        join(localUrl, 'test-file1.txt'),
+        join(sftpUrl, 'mocha-put-string.md')
+      )
+      .then(() => {
+        return sftp.stat(join(sftpUrl, 'mocha-put-string.md'));
+      })
+      .then(stats => {
+        return expect(stats).to.containSubset({size: 6973257});
+      });
+  });
+
+  it('Put data from buffer into remote file', function() {
+    return sftp
+      .put(Buffer.from('hello'), join(sftpUrl, 'mocha-put-buffer.md'), {
+        encoding: 'utf8'
+      })
+      .then(() => {
+        return sftp.stat(join(sftpUrl, 'mocha-put-buffer.md'));
+      })
+      .then(stats => {
+        return expect(stats).to.containSubset({size: 5});
+      });
+  });
+
+  it('Put data from stream into remote file', function() {
+    var str2 = new stream.Readable();
+    str2._read = function noop() {};
+    str2.push('your text here');
+    str2.push(null);
+
+    return sftp
+      .put(str2, join(sftpUrl, 'mocha-put-stream.md'), {encoding: 'utf8'})
+      .then(() => {
+        return sftp.stat(join(sftpUrl, 'mocha-put-stream.md'));
+      })
+      .then(stats => {
+        return expect(stats).to.containSubset({size: 14});
+      });
+  });
+
+  it('Put with no src file should be rejected', function() {
+    return expect(
+      sftp.put(
+        join(localUrl, 'no-such-file.txt'),
+        join(sftpUrl, 'mocha-put-no-file.txt')
+      )
+    ).to.be.rejectedWith('Failed to upload');
+  });
+
+  it('Put with bad dst path should be rejected', function() {
+    return expect(
+      sftp.put(
+        join(localUrl, 'test-file1.txt'),
+        join(sftpUrl, 'bad-directory', 'bad-file.txt')
+      )
+    ).to.be.rejectedWith('Failed to upload');
+  });
+});