mirror of
https://github.com/overleaf/overleaf.git
synced 2024-11-07 20:31:06 -05:00
502 lines
14 KiB
JavaScript
502 lines
14 KiB
JavaScript
/* eslint-disable
|
|
handle-callback-err,
|
|
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
|
|
* DS207: Consider shorter variations of null checks
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
const { assert } = require('chai')
|
|
const sinon = require('sinon')
|
|
const chai = require('chai')
|
|
const { should } = chai
|
|
const { expect } = chai
|
|
const modulePath = '../../../app/js/FSPersistorManager.js'
|
|
const SandboxedModule = require('sandboxed-module')
|
|
const fs = require('fs')
|
|
const response = require('response')
|
|
|
|
describe('FSPersistorManagerTests', function() {
|
|
beforeEach(function() {
|
|
this.Fs = {
|
|
rename: sinon.stub(),
|
|
createReadStream: sinon.stub(),
|
|
createWriteStream: sinon.stub(),
|
|
unlink: sinon.stub(),
|
|
rmdir: sinon.stub(),
|
|
exists: sinon.stub(),
|
|
readdir: sinon.stub(),
|
|
open: sinon.stub(),
|
|
openSync: sinon.stub(),
|
|
fstatSync: sinon.stub(),
|
|
closeSync: sinon.stub(),
|
|
stat: sinon.stub()
|
|
}
|
|
this.Rimraf = sinon.stub()
|
|
this.LocalFileWriter = {
|
|
writeStream: sinon.stub(),
|
|
deleteFile: sinon.stub()
|
|
}
|
|
this.requires = {
|
|
'./LocalFileWriter': this.LocalFileWriter,
|
|
fs: this.Fs,
|
|
'logger-sharelatex': {
|
|
log() {},
|
|
err() {}
|
|
},
|
|
response: response,
|
|
rimraf: this.Rimraf,
|
|
'./Errors': (this.Errors = { NotFoundError: sinon.stub() })
|
|
}
|
|
this.location = '/tmp'
|
|
this.name1 = '530f2407e7ef165704000007/530f838b46d9a9e859000008'
|
|
this.name1Filtered = '530f2407e7ef165704000007_530f838b46d9a9e859000008'
|
|
this.name2 = 'second_file'
|
|
this.error = 'error_message'
|
|
return (this.FSPersistorManager = SandboxedModule.require(modulePath, {
|
|
requires: this.requires
|
|
}))
|
|
})
|
|
|
|
describe('sendFile', function() {
|
|
beforeEach(function() {
|
|
return (this.Fs.createReadStream = sinon.stub().returns({
|
|
on() {},
|
|
pipe() {}
|
|
}))
|
|
})
|
|
|
|
it('should copy the file', function(done) {
|
|
this.Fs.createWriteStream = sinon.stub().returns({
|
|
on(event, handler) {
|
|
if (event === 'finish') {
|
|
return process.nextTick(handler)
|
|
}
|
|
}
|
|
})
|
|
return this.FSPersistorManager.sendFile(
|
|
this.location,
|
|
this.name1,
|
|
this.name2,
|
|
err => {
|
|
this.Fs.createReadStream.calledWith(this.name2).should.equal(true)
|
|
this.Fs.createWriteStream
|
|
.calledWith(`${this.location}/${this.name1Filtered}`)
|
|
.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
return it('should return an error if the file cannot be stored', function(done) {
|
|
this.Fs.createWriteStream = sinon.stub().returns({
|
|
on: (event, handler) => {
|
|
if (event === 'error') {
|
|
return process.nextTick(() => {
|
|
return handler(this.error)
|
|
})
|
|
}
|
|
}
|
|
})
|
|
return this.FSPersistorManager.sendFile(
|
|
this.location,
|
|
this.name1,
|
|
this.name2,
|
|
err => {
|
|
this.Fs.createReadStream.calledWith(this.name2).should.equal(true)
|
|
this.Fs.createWriteStream
|
|
.calledWith(`${this.location}/${this.name1Filtered}`)
|
|
.should.equal(true)
|
|
err.should.equal(this.error)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('sendStream', function() {
|
|
beforeEach(function() {
|
|
this.FSPersistorManager.sendFile = sinon.stub().callsArgWith(3)
|
|
this.LocalFileWriter.writeStream.callsArgWith(2, null, this.name1)
|
|
this.LocalFileWriter.deleteFile.callsArg(1)
|
|
return (this.SourceStream = { on() {} })
|
|
})
|
|
|
|
it('should sent stream to LocalFileWriter', function(done) {
|
|
return this.FSPersistorManager.sendStream(
|
|
this.location,
|
|
this.name1,
|
|
this.SourceStream,
|
|
() => {
|
|
this.LocalFileWriter.writeStream
|
|
.calledWith(this.SourceStream)
|
|
.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should return the error from LocalFileWriter', function(done) {
|
|
this.LocalFileWriter.writeStream.callsArgWith(2, this.error)
|
|
return this.FSPersistorManager.sendStream(
|
|
this.location,
|
|
this.name1,
|
|
this.SourceStream,
|
|
err => {
|
|
err.should.equal(this.error)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
return it('should send the file to the filestore', function(done) {
|
|
this.LocalFileWriter.writeStream.callsArgWith(2)
|
|
return this.FSPersistorManager.sendStream(
|
|
this.location,
|
|
this.name1,
|
|
this.SourceStream,
|
|
err => {
|
|
this.FSPersistorManager.sendFile.called.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('getFileStream', function() {
|
|
beforeEach(function() {
|
|
return (this.opts = {})
|
|
})
|
|
|
|
it('should use correct file location', function(done) {
|
|
this.FSPersistorManager.getFileStream(
|
|
this.location,
|
|
this.name1,
|
|
this.opts,
|
|
(err, res) => {}
|
|
)
|
|
this.Fs.open
|
|
.calledWith(`${this.location}/${this.name1Filtered}`)
|
|
.should.equal(true)
|
|
return done()
|
|
})
|
|
|
|
describe('with start and end options', function() {
|
|
beforeEach(function() {
|
|
this.fd = 2019
|
|
this.opts_in = { start: 0, end: 8 }
|
|
this.opts = { start: 0, end: 8, fd: this.fd }
|
|
return this.Fs.open.callsArgWith(2, null, this.fd)
|
|
})
|
|
|
|
return it('should pass the options to createReadStream', function(done) {
|
|
this.FSPersistorManager.getFileStream(
|
|
this.location,
|
|
this.name1,
|
|
this.opts_in,
|
|
(err, res) => {}
|
|
)
|
|
this.Fs.createReadStream.calledWith(null, this.opts).should.equal(true)
|
|
return done()
|
|
})
|
|
})
|
|
|
|
return describe('error conditions', function() {
|
|
describe('when the file does not exist', function() {
|
|
beforeEach(function() {
|
|
this.fakeCode = 'ENOENT'
|
|
const err = new Error()
|
|
err.code = this.fakeCode
|
|
return this.Fs.open.callsArgWith(2, err, null)
|
|
})
|
|
|
|
return it('should give a NotFoundError', function(done) {
|
|
return this.FSPersistorManager.getFileStream(
|
|
this.location,
|
|
this.name1,
|
|
this.opts,
|
|
(err, res) => {
|
|
expect(res).to.equal(null)
|
|
expect(err).to.not.equal(null)
|
|
expect(err instanceof this.Errors.NotFoundError).to.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
return describe('when some other error happens', function() {
|
|
beforeEach(function() {
|
|
this.fakeCode = 'SOMETHINGHORRIBLE'
|
|
const err = new Error()
|
|
err.code = this.fakeCode
|
|
return this.Fs.open.callsArgWith(2, err, null)
|
|
})
|
|
|
|
return it('should give an Error', function(done) {
|
|
return this.FSPersistorManager.getFileStream(
|
|
this.location,
|
|
this.name1,
|
|
this.opts,
|
|
(err, res) => {
|
|
expect(res).to.equal(null)
|
|
expect(err).to.not.equal(null)
|
|
expect(err instanceof Error).to.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('getFileSize', function() {
|
|
it('should return the file size', function(done) {
|
|
const expectedFileSize = 75382
|
|
this.Fs.stat.yields(new Error('fs.stat got unexpected arguments'))
|
|
this.Fs.stat
|
|
.withArgs(`${this.location}/${this.name1Filtered}`)
|
|
.yields(null, { size: expectedFileSize })
|
|
|
|
return this.FSPersistorManager.getFileSize(
|
|
this.location,
|
|
this.name1,
|
|
(err, fileSize) => {
|
|
if (err != null) {
|
|
return done(err)
|
|
}
|
|
expect(fileSize).to.equal(expectedFileSize)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should throw a NotFoundError if the file does not exist', function(done) {
|
|
const error = new Error()
|
|
error.code = 'ENOENT'
|
|
this.Fs.stat.yields(error)
|
|
|
|
return this.FSPersistorManager.getFileSize(
|
|
this.location,
|
|
this.name1,
|
|
(err, fileSize) => {
|
|
expect(err).to.be.instanceof(this.Errors.NotFoundError)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
return it('should rethrow any other error', function(done) {
|
|
const error = new Error()
|
|
this.Fs.stat.yields(error)
|
|
|
|
return this.FSPersistorManager.getFileSize(
|
|
this.location,
|
|
this.name1,
|
|
(err, fileSize) => {
|
|
expect(err).to.equal(error)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('copyFile', function() {
|
|
beforeEach(function() {
|
|
this.ReadStream = {
|
|
on() {},
|
|
pipe: sinon.stub()
|
|
}
|
|
this.WriteStream = { on() {} }
|
|
this.Fs.createReadStream.returns(this.ReadStream)
|
|
return this.Fs.createWriteStream.returns(this.WriteStream)
|
|
})
|
|
|
|
it('Should open the source for reading', function(done) {
|
|
this.FSPersistorManager.copyFile(
|
|
this.location,
|
|
this.name1,
|
|
this.name2,
|
|
function() {}
|
|
)
|
|
this.Fs.createReadStream
|
|
.calledWith(`${this.location}/${this.name1Filtered}`)
|
|
.should.equal(true)
|
|
return done()
|
|
})
|
|
|
|
it('Should open the target for writing', function(done) {
|
|
this.FSPersistorManager.copyFile(
|
|
this.location,
|
|
this.name1,
|
|
this.name2,
|
|
function() {}
|
|
)
|
|
this.Fs.createWriteStream
|
|
.calledWith(`${this.location}/${this.name2}`)
|
|
.should.equal(true)
|
|
return done()
|
|
})
|
|
|
|
return it('Should pipe the source to the target', function(done) {
|
|
this.FSPersistorManager.copyFile(
|
|
this.location,
|
|
this.name1,
|
|
this.name2,
|
|
function() {}
|
|
)
|
|
this.ReadStream.pipe.calledWith(this.WriteStream).should.equal(true)
|
|
return done()
|
|
})
|
|
})
|
|
|
|
describe('deleteFile', function() {
|
|
beforeEach(function() {
|
|
return this.Fs.unlink.callsArgWith(1, this.error)
|
|
})
|
|
|
|
it('Should call unlink with correct options', function(done) {
|
|
return this.FSPersistorManager.deleteFile(
|
|
this.location,
|
|
this.name1,
|
|
err => {
|
|
this.Fs.unlink
|
|
.calledWith(`${this.location}/${this.name1Filtered}`)
|
|
.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
return it('Should propogate the error', function(done) {
|
|
return this.FSPersistorManager.deleteFile(
|
|
this.location,
|
|
this.name1,
|
|
err => {
|
|
err.should.equal(this.error)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('deleteDirectory', function() {
|
|
beforeEach(function() {
|
|
return this.Rimraf.callsArgWith(1, this.error)
|
|
})
|
|
|
|
it('Should call rmdir(rimraf) with correct options', function(done) {
|
|
return this.FSPersistorManager.deleteDirectory(
|
|
this.location,
|
|
this.name1,
|
|
err => {
|
|
this.Rimraf.calledWith(
|
|
`${this.location}/${this.name1Filtered}`
|
|
).should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
return it('Should propogate the error', function(done) {
|
|
return this.FSPersistorManager.deleteDirectory(
|
|
this.location,
|
|
this.name1,
|
|
err => {
|
|
err.should.equal(this.error)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('checkIfFileExists', function() {
|
|
beforeEach(function() {
|
|
return this.Fs.exists.callsArgWith(1, true)
|
|
})
|
|
|
|
it('Should call exists with correct options', function(done) {
|
|
return this.FSPersistorManager.checkIfFileExists(
|
|
this.location,
|
|
this.name1,
|
|
exists => {
|
|
this.Fs.exists
|
|
.calledWith(`${this.location}/${this.name1Filtered}`)
|
|
.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
// fs.exists simply returns false on any error, so...
|
|
it('should not return an error', function(done) {
|
|
return this.FSPersistorManager.checkIfFileExists(
|
|
this.location,
|
|
this.name1,
|
|
(err, exists) => {
|
|
expect(err).to.be.null
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('Should return true for existing files', function(done) {
|
|
this.Fs.exists.callsArgWith(1, true)
|
|
return this.FSPersistorManager.checkIfFileExists(
|
|
this.location,
|
|
this.name1,
|
|
(err, exists) => {
|
|
exists.should.be.true
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
return it('Should return false for non-existing files', function(done) {
|
|
this.Fs.exists.callsArgWith(1, false)
|
|
return this.FSPersistorManager.checkIfFileExists(
|
|
this.location,
|
|
this.name1,
|
|
(err, exists) => {
|
|
exists.should.be.false
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
return describe('directorySize', function() {
|
|
it('should propogate the error', function(done) {
|
|
this.Fs.readdir.callsArgWith(1, this.error)
|
|
return this.FSPersistorManager.directorySize(
|
|
this.location,
|
|
this.name1,
|
|
(err, totalsize) => {
|
|
err.should.equal(this.error)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
return it('should sum directory files size', function(done) {
|
|
this.Fs.readdir.callsArgWith(1, null, [
|
|
{ file1: 'file1' },
|
|
{ file2: 'file2' }
|
|
])
|
|
this.Fs.fstatSync.returns({ size: 1024 })
|
|
return this.FSPersistorManager.directorySize(
|
|
this.location,
|
|
this.name1,
|
|
(err, totalsize) => {
|
|
expect(totalsize).to.equal(2048)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|