ftp-server/test/index.spec.js

/* eslint no-unused-expressions: 0 */
const { expect } = require('chai')
const sinon = require('sinon')
const bunyan = require('bunyan')
const Promise = require('bluebird')
const _ = require('lodash')
const fs = require('fs')
const nodePath = require('path')

const FtpServer = require('../src')
const FtpClient = require('@icetee/ftp')

describe('Integration', function () {
  this.timeout(4000)

  let client
  let sandbox
  let log = bunyan.createLogger({ name: 'test-runner' })
  let server

  let connection
  const clientDirectory = `${process.cwd()}/test_tmp`

  before(() => {
    return startServer({ url: 'ftp://127.0.0.1:8880' })
  })

  beforeEach(() => {
    sandbox = sinon.sandbox.create().usingPromise(Promise)
  })

  afterEach(() => sandbox.restore())

  after(() => server.close())

  before(() => {
    directoryPurge(clientDirectory)
    fs.mkdirSync(clientDirectory)
  })
  after(() => directoryPurge(clientDirectory))

  function readFile(path) {
    return new Promise((resolve, reject) => {
      fs.readFile(path, 'utf8', (err, data) => {
        if (err) reject(err)
        else resolve(data)
      })
    })
  }

  function startServer(options = {}) {
    server = new FtpServer(
      _.assign(
        {
          log,
          pasv_url: '127.0.0.1',
          pasv_min: 8881,
          greeting: ['hello', 'world'],
          anonymous: true
        },
        options
      )
    )
    server.on('login', (data, resolve) => {
      connection = data.connection
      resolve({ root: clientDirectory })
    })

    return server.listen()
  }

  function connectClient(options = {}) {
    return new Promise((resolve, reject) => {
      client = new FtpClient()
      client.once('ready', () => resolve(client))
      client.once('error', (err) => reject(err))
      client.connect(
        _.assign(
          {
            host: server.url.hostname,
            port: server.url.port,
            user: 'test',
            password: 'test'
          },
          options
        )
      )
    }).then((instance) => {
      client = instance
    })
  }

  function closeClient() {
    return new Promise((resolve, reject) => {
      client.once('close', () => resolve())
      client.once('error', (err) => reject(err))
      client.logout((err) => {
        expect(err).to.be.undefined
      })
    })
  }

  function directoryPurge(dir) {
    const dirExists = fs.existsSync(dir)
    if (!dirExists) return

    const list = fs.readdirSync(dir)
    list
      .map((item) => nodePath.resolve(dir, item))
      .forEach((item) => {
        const itemExists = fs.existsSync(dir)
        if (!itemExists) return

        const stat = fs.statSync(item)
        if (stat.isDirectory()) directoryPurge(item)
        else fs.unlinkSync(item)
      })

    fs.rmdirSync(dir, { recursive: true })
  }

  function runFileSystemTests(name) {
    before(() => {
      directoryPurge(`${clientDirectory}/${name}/`)
      fs.mkdirSync(`${clientDirectory}/${name}/`)
      fs.writeFileSync(`${clientDirectory}/${name}/fake.txt`, 'Fake file')
    })

    after(() => directoryPurge(`${clientDirectory}/${name}/`))

    it('STAT', (done) => {
      client.status((err, status) => {
        expect(err).to.not.exist
        expect(status).to.equal('Status OK')
        done()
      })
    })

    it('SYST', (done) => {
      client.system((err, os) => {
        expect(err).to.not.exist
        expect(os).to.equal('UNIX')
        done()
      })
    })

    it('CWD ..', (done) => {
      client.cwd('..', (err, data) => {
        expect(err).to.not.exist
        expect(data).to.equal('/')
        done()
      })
    })

    it(`CWD ${name}`, (done) => {
      client.cwd(`${name}`, (err, data) => {
        expect(err).to.not.exist
        expect(data).to.equal(`/${name}`)
        done()
      })
    })

    it('PWD', (done) => {
      client.pwd((err, data) => {
        expect(err).to.not.exist
        expect(data).to.equal(`/${name}`)
        done()
      })
    })

    it('LIST .', (done) => {
      client.list('.', (err, data) => {
        expect(err).to.not.exist
        expect(data).to.be.an('array')
        expect(data.length).to.equal(1)
        expect(data[0].name).to.equal('fake.txt')
        done()
      })
    })

    it('LIST fake.txt', (done) => {
      client.list('fake.txt', (err, data) => {
        expect(err).to.not.exist
        expect(data).to.be.an('array')
        expect(data.length).to.equal(1)
        expect(data[0].name).to.equal('fake.txt')
        done()
      })
    })

    it('STOR fail.txt', (done) => {
      const buffer = Buffer.from('test text file')
      const fsPath = `${clientDirectory}/${name}/fail.txt`

      sandbox.stub(connection.fs, 'write').callsFake(function () {
        const stream = fs.createWriteStream(fsPath, { flags: 'w+', autoClose: false })
        stream.on('error', () => fs.existsSync(fsPath) && fs.unlinkSync(fsPath))
        stream.on('close', () => stream.end())
        setImmediate(() => stream.emit('error', new Error('STOR fail test')))
        return stream
      })

      client.put(buffer, 'fail.txt', (err) => {
        expect(err).to.exist
        setImmediate(() => {
          const fileExists = fs.existsSync(fsPath)
          expect(fileExists).to.equal(false)
          done()
        })
      })
    })

    it('STOR tést.txt', (done) => {
      const buffer = Buffer.from('test text file')
      const fsPath = `${clientDirectory}/${name}/tést.txt`

      connection.once('STOR', (err) => {
        expect(err).to.not.exist
      })

      client.put(buffer, 'tést.txt', (err) => {
        expect(err).to.not.exist
        setImmediate(() => {
          expect(fs.existsSync(fsPath)).to.equal(true)
          fs.readFile(fsPath, (fserr, data) => {
            expect(fserr).to.not.exist
            expect(data.toString()).to.equal('test text file')
            done()
          })
        })
      })
    })

    it('STOR logo.png', (done) => {
      const logo = `${__dirname}/../logo.png`
      const fsPath = `${clientDirectory}/${name}/logo.png`

      client.put(logo, 'logo.png', (err) => {
        expect(err).to.not.exist
        setImmediate(() => {
          expect(fs.existsSync(fsPath)).to.equal(true)

          const logoContents = fs.readFileSync(logo)
          const transferedContects = fs.readFileSync(fsPath)

          expect(logoContents.equals(transferedContects))
          done()
        })
      })
    })

    it('APPE tést.txt', (done) => {
      const buffer = Buffer.from(', awesome!')
      const fsPath = `${clientDirectory}/${name}/tést.txt`
      client.append(buffer, 'tést.txt', (err) => {
        expect(err).to.not.exist
        setImmediate(() => {
          expect(fs.existsSync(fsPath)).to.equal(true)
          fs.readFile(fsPath, (fserr, data) => {
            expect(fserr).to.not.exist
            expect(data.toString()).to.equal('test text file, awesome!')
            done()
          })
        })
      })
    })

    it('RETR tést.txt', (done) => {
      connection.once('RETR', (err) => {
        expect(err).to.not.exist
      })

      client.get('tést.txt', (err, stream) => {
        expect(err).to.not.exist
        let text = ''

        stream.on('data', (data) => {
          text += data.toString()
        })

        stream.on('finish', () => {
          expect(text).to.equal('test text file, awesome!')
          done()
        })

        stream.resume()
      })
    })

    it('RNFR tést.txt, RNTO awesome.txt', (done) => {
      client.rename('tést.txt', 'awesome.txt', (err) => {
        expect(err).to.not.exist
        expect(fs.existsSync(`${clientDirectory}/${name}/tést.txt`)).to.equal(false)
        expect(fs.existsSync(`${clientDirectory}/${name}/awesome.txt`)).to.equal(true)
        fs.readFile(`${clientDirectory}/${name}/awesome.txt`, (fserr, data) => {
          expect(fserr).to.not.exist
          expect(data.toString()).to.equal('test text file, awesome!')
          done()
        })
      })
    })

    it('SIZE awesome.txt', (done) => {
      client.size('awesome.txt', (err, size) => {
        expect(err).to.not.exist
        expect(size).to.be.a('number')
        done()
      })
    })

    it('MDTM awesome.txt', (done) => {
      client.lastMod('awesome.txt', (err, modTime) => {
        expect(err).to.not.exist
        expect(modTime).to.be.instanceOf(Date)
        expect(modTime.toISOString()).to.match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/)
        done()
      })
    })

    it.skip('MLSD .', (done) => {
      client.mlsd('.', () => {
        done()
      })
    })

    it('SITE CHMOD 700 awesome.txt', (done) => {
      client.site('CHMOD 600 awesome.txt', (err) => {
        expect(err).to.not.exist
        fs.stat(`${clientDirectory}/${name}/awesome.txt`, (fserr, stats) => {
          expect(fserr).to.not.exist
          const mode = stats.mode.toString(8)
          expect(/600$/.test(mode)).to.equal(true)
          done()
        })
      })
    })

    it('DELE awesome.txt', (done) => {
      client.delete('awesome.txt', (err) => {
        expect(err).to.not.exist
        expect(fs.existsSync(`${clientDirectory}/${name}/awesome.txt`)).to.equal(false)
        done()
      })
    })

    it('MKD témp', (done) => {
      const path = `${clientDirectory}/${name}/témp`
      if (fs.existsSync(path)) {
        fs.rmdirSync(path)
      }
      client.mkdir('témp', (err) => {
        expect(err).to.not.exist
        expect(fs.existsSync(path)).to.equal(true)
        done()
      })
    })

    it('MKD témp multiple levels deep', (done) => {
      const path = `${clientDirectory}/${name}/témp`
      if (fs.existsSync(path)) {
        fs.rmdirSync(path, { recursive: true })
      }

      client.mkdir('témp/first/second', (err) => {
        expect(err).to.not.exist
        expect(fs.existsSync(path)).to.equal(true)

        fs.rmdirSync(path, { recursive: true })
        done()
      })
    })

    it('CWD témp', (done) => {
      const path = `${clientDirectory}/${name}/témp`
      fs.mkdirSync(path)

      client.cwd('témp', (err, data) => {
        expect(err).to.not.exist
        expect(data).to.to.be.a('string')
        done()
      })
    })

    it('CDUP', (done) => {
      client.cdup((err) => {
        expect(err).to.not.exist
        done()
      })
    })

    it('RMD témp', (done) => {
      client.rmdir('témp', (err) => {
        expect(err).to.not.exist
        expect(fs.existsSync(`${clientDirectory}/${name}/témp`)).to.equal(false)
        done()
      })
    })

    it('CDUP', (done) => {
      client.cdup((err) => {
        expect(err).to.not.exist
        done()
      })
    })
  }

  describe('Server events', function () {
    const disconnect = sinon.spy()
    const login = sinon.spy()

    before(() => {
      server.on('login', login)
      server.on('disconnect', disconnect)
      return connectClient({
        host: server.url.hostname,
        port: server.url.port,
        user: 'test',
        password: 'test'
      })
    })

    after(() => {
      server.off('login', login)
      server.off('disconnect', disconnect)
    })

    it('should fire a login event on connect', () => {
      expect(login.calledOnce).to.be.true
    })

    it('should fire a close event on disconnect', (done) => {
      client.end()
      setTimeout(() => {
        expect(disconnect.calledOnce).to.be.true
        done()
      }, 100)
    })
  })

  describe('#ASCII', function () {
    before(() => {
      return connectClient({
        host: server.url.hostname,
        port: server.url.port,
        user: 'test',
        password: 'test'
      })
    })

    after(() => closeClient(client))

    it('TYPE A', (done) => {
      client.ascii((err) => {
        expect(err).to.not.exist
        done()
      })
    })

    runFileSystemTests('ascii')
  })

  describe('#BINARY', function () {
    before(() => {
      return connectClient({
        host: server.url.hostname,
        port: server.url.port,
        user: 'test',
        password: 'test'
      })
    })

    after(() => closeClient(client))

    it('TYPE I', (done) => {
      client.binary((err) => {
        expect(err).to.not.exist
        done()
      })
    })

    runFileSystemTests('binary')
  })

  describe('#EXPLICIT', function () {
    before(() => {
      return server
        .close()
        .then(() =>
          Promise.all([
            readFile(`${process.cwd()}/test/cert/server.key`),
            readFile(`${process.cwd()}/test/cert/server.crt`),
            readFile(`${process.cwd()}/test/cert/server.csr`)
          ])
        )
        .then(([key, cert, ca]) =>
          startServer({
            url: 'ftp://127.0.0.1:8881',
            tls: { key, cert, ca }
          })
        )
        .then(() => {
          return connectClient({
            secure: true,
            secureOptions: {
              rejectUnauthorized: false,
              checkServerIdentity: () => undefined
            }
          })
        })
    })

    after(() => closeClient())

    runFileSystemTests('explicit')
  })

  describe.skip('#IMPLICIT', function () {
    before(() => {
      return server
        .close()
        .then(() =>
          Promise.all([
            readFile(`${process.cwd()}/test/cert/server.key`),
            readFile(`${process.cwd()}/test/cert/server.crt`),
            readFile(`${process.cwd()}/test/cert/server.csr`)
          ])
        )
        .then(([key, cert, ca]) =>
          startServer({
            url: 'ftps://127.0.0.1:8882',
            tls: { key, cert, ca }
          })
        )
        .then(() => {
          return connectClient({
            secure: 'implicit',
            secureOptions: {
              rejectUnauthorized: false,
              checkServerIdentity: () => undefined
            }
          })
        })
    })

    after(() => closeClient())

    runFileSystemTests('implicit')
  })
})