Overleaf/services/filestore/test/unit/js/AWSSDKPersistorManagerTests.js

/* eslint-disable
    handle-callback-err,
    no-dupe-keys,
    no-return-assign,
    no-unused-vars,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
 * decaffeinate suggestions:
 * DS102: Remove unnecessary code created because of implicit returns
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
const sinon = require('sinon')
const chai = require('chai')

const should = chai.should()
const { expect } = chai

const modulePath = '../../../app/js/AWSSDKPersistorManager.js'
const SandboxedModule = require('sandboxed-module')

describe('AWSSDKPersistorManager', function() {
  beforeEach(function() {
    this.settings = {
      filestore: {
        backend: 'aws-sdk'
      }
    }
    this.s3 = {
      upload: sinon.stub(),
      getObject: sinon.stub(),
      copyObject: sinon.stub(),
      deleteObject: sinon.stub(),
      listObjects: sinon.stub(),
      deleteObjects: sinon.stub(),
      headObject: sinon.stub()
    }
    this.awssdk = { S3: sinon.stub().returns(this.s3) }

    this.requires = {
      'aws-sdk': this.awssdk,
      'settings-sharelatex': this.settings,
      'logger-sharelatex': {
        log() {},
        err() {}
      },
      fs: (this.fs = { createReadStream: sinon.stub() }),
      './Errors': (this.Errors = { NotFoundError: sinon.stub() })
    }
    this.key = 'my/key'
    this.bucketName = 'my-bucket'
    this.error = 'my error'
    return (this.AWSSDKPersistorManager = SandboxedModule.require(modulePath, {
      requires: this.requires
    }))
  })

  describe('sendFile', function() {
    beforeEach(function() {
      this.stream = {}
      this.fsPath = '/usr/local/some/file'
      return this.fs.createReadStream.returns(this.stream)
    })

    it('should put the file with s3.upload', function(done) {
      this.s3.upload.callsArgWith(1)
      return this.AWSSDKPersistorManager.sendFile(
        this.bucketName,
        this.key,
        this.fsPath,
        err => {
          expect(err).to.not.be.ok
          expect(this.s3.upload.calledOnce, 'called only once').to.be.true
          expect(
            this.s3.upload.calledWith({
              Bucket: this.bucketName,
              Key: this.key,
              Body: this.stream
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    return it('should dispatch the error from s3.upload', function(done) {
      this.s3.upload.callsArgWith(1, this.error)
      return this.AWSSDKPersistorManager.sendFile(
        this.bucketName,
        this.key,
        this.fsPath,
        err => {
          expect(err).to.equal(this.error)
          return done()
        }
      )
    })
  })

  describe('sendStream', function() {
    beforeEach(function() {
      return (this.stream = {})
    })

    it('should put the file with s3.upload', function(done) {
      this.s3.upload.callsArgWith(1)
      return this.AWSSDKPersistorManager.sendStream(
        this.bucketName,
        this.key,
        this.stream,
        err => {
          expect(err).to.not.be.ok
          expect(this.s3.upload.calledOnce, 'called only once').to.be.true
          expect(
            this.s3.upload.calledWith({
              Bucket: this.bucketName,
              Key: this.key,
              Body: this.stream
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    return it('should dispatch the error from s3.upload', function(done) {
      this.s3.upload.callsArgWith(1, this.error)
      return this.AWSSDKPersistorManager.sendStream(
        this.bucketName,
        this.key,
        this.stream,
        err => {
          expect(err).to.equal(this.error)
          return done()
        }
      )
    })
  })

  describe('getFileStream', function() {
    beforeEach(function() {
      this.opts = {}
      this.stream = {}
      this.read_stream = { on: (this.read_stream_on = sinon.stub()) }
      this.object = { createReadStream: sinon.stub().returns(this.read_stream) }
      return this.s3.getObject.returns(this.object)
    })

    it('should return a stream from s3.getObject', function(done) {
      this.read_stream_on.withArgs('readable').callsArgWith(1)

      return this.AWSSDKPersistorManager.getFileStream(
        this.bucketName,
        this.key,
        this.opts,
        (err, stream) => {
          expect(this.read_stream_on.calledTwice)
          expect(err).to.not.be.ok
          expect(stream, 'returned the stream').to.equal(this.read_stream)
          expect(
            this.s3.getObject.calledWith({
              Bucket: this.bucketName,
              Key: this.key
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    describe('with start and end options', function() {
      beforeEach(function() {
        return (this.opts = {
          start: 0,
          end: 8
        })
      })
      return it('should pass headers to the s3.GetObject', function(done) {
        this.read_stream_on.withArgs('readable').callsArgWith(1)
        this.AWSSDKPersistorManager.getFileStream(
          this.bucketName,
          this.key,
          this.opts,
          (err, stream) => {
            return expect(
              this.s3.getObject.calledWith({
                Bucket: this.bucketName,
                Key: this.key,
                Range: 'bytes=0-8'
              }),
              'called with correct arguments'
            ).to.be.true
          }
        )
        return done()
      })
    })

    return describe('error conditions', function() {
      describe("when the file doesn't exist", function() {
        beforeEach(function() {
          this.error = new Error()
          return (this.error.code = 'NoSuchKey')
        })
        return it('should produce a NotFoundError', function(done) {
          this.read_stream_on.withArgs('error').callsArgWith(1, this.error)
          return this.AWSSDKPersistorManager.getFileStream(
            this.bucketName,
            this.key,
            this.opts,
            (err, stream) => {
              expect(stream).to.not.be.ok
              expect(err).to.be.ok
              expect(
                err instanceof this.Errors.NotFoundError,
                'error is a correct instance'
              ).to.equal(true)
              return done()
            }
          )
        })
      })

      return describe('when there is some other error', function() {
        beforeEach(function() {
          return (this.error = new Error())
        })
        return it('should dispatch the error from s3 object stream', function(done) {
          this.read_stream_on.withArgs('error').callsArgWith(1, this.error)
          return this.AWSSDKPersistorManager.getFileStream(
            this.bucketName,
            this.key,
            this.opts,
            (err, stream) => {
              expect(stream).to.not.be.ok
              expect(err).to.be.ok
              expect(err).to.equal(this.error)
              return done()
            }
          )
        })
      })
    })
  })

  describe('copyFile', function() {
    beforeEach(function() {
      this.destKey = 'some/key'
      return (this.stream = {})
    })

    it('should copy the file with s3.copyObject', function(done) {
      this.s3.copyObject.callsArgWith(1)
      return this.AWSSDKPersistorManager.copyFile(
        this.bucketName,
        this.key,
        this.destKey,
        err => {
          expect(err).to.not.be.ok
          expect(this.s3.copyObject.calledOnce, 'called only once').to.be.true
          expect(
            this.s3.copyObject.calledWith({
              Bucket: this.bucketName,
              Key: this.destKey,
              CopySource: this.bucketName + '/' + this.key
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    return it('should dispatch the error from s3.copyObject', function(done) {
      this.s3.copyObject.callsArgWith(1, this.error)
      return this.AWSSDKPersistorManager.copyFile(
        this.bucketName,
        this.key,
        this.destKey,
        err => {
          expect(err).to.equal(this.error)
          return done()
        }
      )
    })
  })

  describe('deleteFile', function() {
    it('should delete the file with s3.deleteObject', function(done) {
      this.s3.deleteObject.callsArgWith(1)
      return this.AWSSDKPersistorManager.deleteFile(
        this.bucketName,
        this.key,
        err => {
          expect(err).to.not.be.ok
          expect(this.s3.deleteObject.calledOnce, 'called only once').to.be.true
          expect(
            this.s3.deleteObject.calledWith({
              Bucket: this.bucketName,
              Key: this.key
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    return it('should dispatch the error from s3.deleteObject', function(done) {
      this.s3.deleteObject.callsArgWith(1, this.error)
      return this.AWSSDKPersistorManager.deleteFile(
        this.bucketName,
        this.key,
        err => {
          expect(err).to.equal(this.error)
          return done()
        }
      )
    })
  })

  describe('deleteDirectory', function() {
    it('should list the directory content using s3.listObjects', function(done) {
      this.s3.listObjects.callsArgWith(1, null, { Contents: [] })
      return this.AWSSDKPersistorManager.deleteDirectory(
        this.bucketName,
        this.key,
        err => {
          expect(err).to.not.be.ok
          expect(this.s3.listObjects.calledOnce, 'called only once').to.be.true
          expect(
            this.s3.listObjects.calledWith({
              Bucket: this.bucketName,
              Prefix: this.key
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    it('should dispatch the error from s3.listObjects', function(done) {
      this.s3.listObjects.callsArgWith(1, this.error)
      return this.AWSSDKPersistorManager.deleteDirectory(
        this.bucketName,
        this.key,
        err => {
          expect(err).to.equal(this.error)
          return done()
        }
      )
    })

    return describe('with directory content', function() {
      beforeEach(function() {
        return (this.fileList = [{ Key: 'foo' }, { Key: 'bar', Key: 'baz' }])
      })

      it('should forward the file keys to s3.deleteObjects', function(done) {
        this.s3.listObjects.callsArgWith(1, null, { Contents: this.fileList })
        this.s3.deleteObjects.callsArgWith(1)
        return this.AWSSDKPersistorManager.deleteDirectory(
          this.bucketName,
          this.key,
          err => {
            expect(err).to.not.be.ok
            expect(this.s3.deleteObjects.calledOnce, 'called only once').to.be
              .true
            expect(
              this.s3.deleteObjects.calledWith({
                Bucket: this.bucketName,
                Delete: {
                  Quiet: true,
                  Objects: this.fileList
                }
              }),
              'called with correct arguments'
            ).to.be.true
            return done()
          }
        )
      })

      return it('should dispatch the error from s3.deleteObjects', function(done) {
        this.s3.listObjects.callsArgWith(1, null, { Contents: this.fileList })
        this.s3.deleteObjects.callsArgWith(1, this.error)
        return this.AWSSDKPersistorManager.deleteDirectory(
          this.bucketName,
          this.key,
          err => {
            expect(err).to.equal(this.error)
            return done()
          }
        )
      })
    })
  })

  describe('checkIfFileExists', function() {
    it('should check for the file with s3.headObject', function(done) {
      this.s3.headObject.callsArgWith(1, null, {})
      return this.AWSSDKPersistorManager.checkIfFileExists(
        this.bucketName,
        this.key,
        (err, exists) => {
          expect(err).to.not.be.ok
          expect(this.s3.headObject.calledOnce, 'called only once').to.be.true
          expect(
            this.s3.headObject.calledWith({
              Bucket: this.bucketName,
              Key: this.key
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    it('should return false on an inexistant file', function(done) {
      this.s3.headObject.callsArgWith(1, null, {})
      return this.AWSSDKPersistorManager.checkIfFileExists(
        this.bucketName,
        this.key,
        (err, exists) => {
          expect(exists).to.be.false
          return done()
        }
      )
    })

    it('should return true on an existing file', function(done) {
      this.s3.headObject.callsArgWith(1, null, { ETag: 'etag' })
      return this.AWSSDKPersistorManager.checkIfFileExists(
        this.bucketName,
        this.key,
        (err, exists) => {
          expect(exists).to.be.true
          return done()
        }
      )
    })

    return it('should dispatch the error from s3.headObject', function(done) {
      this.s3.headObject.callsArgWith(1, this.error)
      return this.AWSSDKPersistorManager.checkIfFileExists(
        this.bucketName,
        this.key,
        (err, exists) => {
          expect(err).to.equal(this.error)
          return done()
        }
      )
    })
  })

  return describe('directorySize', function() {
    it('should list the directory content using s3.listObjects', function(done) {
      this.s3.listObjects.callsArgWith(1, null, { Contents: [] })
      return this.AWSSDKPersistorManager.directorySize(
        this.bucketName,
        this.key,
        err => {
          expect(err).to.not.be.ok
          expect(this.s3.listObjects.calledOnce, 'called only once').to.be.true
          expect(
            this.s3.listObjects.calledWith({
              Bucket: this.bucketName,
              Prefix: this.key
            }),
            'called with correct arguments'
          ).to.be.true
          return done()
        }
      )
    })

    it('should dispatch the error from s3.listObjects', function(done) {
      this.s3.listObjects.callsArgWith(1, this.error)
      return this.AWSSDKPersistorManager.directorySize(
        this.bucketName,
        this.key,
        err => {
          expect(err).to.equal(this.error)
          return done()
        }
      )
    })

    return it('should sum directory files sizes', function(done) {
      this.s3.listObjects.callsArgWith(1, null, {
        Contents: [{ Size: 1024 }, { Size: 2048 }]
      })
      return this.AWSSDKPersistorManager.directorySize(
        this.bucketName,
        this.key,
        (err, size) => {
          expect(size).to.equal(3072)
          return done()
        }
      )
    })
  })
})