mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-23 02:55:13 -04:00
1266 lines
36 KiB
JavaScript
1266 lines
36 KiB
JavaScript
|
/* eslint-disable
|
||
|
camelcase,
|
||
|
handle-callback-err,
|
||
|
max-len,
|
||
|
no-return-assign,
|
||
|
no-unused-vars,
|
||
|
standard/no-callback-literal,
|
||
|
*/
|
||
|
// 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 chai = require('chai')
|
||
|
const { expect } = chai
|
||
|
const { assert } = require('chai')
|
||
|
const should = chai.should()
|
||
|
const sinon = require('sinon')
|
||
|
const tk = require('timekeeper')
|
||
|
const modulePath =
|
||
|
'../../../../app/src/Features/Project/ProjectEntityMongoUpdateHandler'
|
||
|
const Errors = require('../../../../app/src/Features/Errors/Errors')
|
||
|
const { ObjectId } = require('mongoose').Types
|
||
|
const SandboxedModule = require('sandboxed-module')
|
||
|
|
||
|
describe('ProjectEntityMongoUpdateHandler', function() {
|
||
|
const project_id = '4eecb1c1bffa66588e0000a1'
|
||
|
const doc_id = '4eecb1c1bffa66588e0000a2'
|
||
|
const file_id = '4eecb1c1bffa66588e0000a3'
|
||
|
const folder_id = '4eecaffcbffa66588e000008'
|
||
|
|
||
|
beforeEach(function() {
|
||
|
let Folder
|
||
|
this.FolderModel = Folder = class Folder {
|
||
|
constructor(options) {
|
||
|
;({ name: this.name } = options)
|
||
|
this._id = 'folder_id'
|
||
|
}
|
||
|
}
|
||
|
|
||
|
this.docName = 'doc-name'
|
||
|
this.fileName = 'something.jpg'
|
||
|
this.project = { _id: project_id, name: 'project name' }
|
||
|
|
||
|
this.callback = sinon.stub()
|
||
|
|
||
|
tk.freeze(Date.now())
|
||
|
return (this.subject = SandboxedModule.require(modulePath, {
|
||
|
requires: {
|
||
|
'logger-sharelatex': (this.logger = {
|
||
|
log: sinon.stub(),
|
||
|
error: sinon.stub(),
|
||
|
err() {}
|
||
|
}),
|
||
|
'settings-sharelatex': (this.settings = {
|
||
|
maxEntitiesPerProject: 100
|
||
|
}),
|
||
|
'../Cooldown/CooldownManager': (this.CooldownManager = {}),
|
||
|
'../../models/Folder': {
|
||
|
Folder: this.FolderModel
|
||
|
},
|
||
|
'../../infrastructure/LockManager': (this.LockManager = {
|
||
|
runWithLock: sinon.spy((namespace, id, runner, callback) =>
|
||
|
runner(callback)
|
||
|
)
|
||
|
}),
|
||
|
'../../models/Project': {
|
||
|
Project: (this.ProjectModel = {})
|
||
|
},
|
||
|
'./ProjectEntityHandler': (this.ProjectEntityHandler = {}),
|
||
|
'./ProjectLocator': (this.ProjectLocator = {}),
|
||
|
'./ProjectGetter': (this.ProjectGetter = {
|
||
|
getProjectWithoutLock: sinon.stub().yields(null, this.project)
|
||
|
})
|
||
|
}
|
||
|
}))
|
||
|
})
|
||
|
|
||
|
afterEach(() => tk.reset())
|
||
|
|
||
|
describe('addDoc', function() {
|
||
|
beforeEach(function() {
|
||
|
this.subject._confirmFolder = sinon.stub().yields(folder_id)
|
||
|
this.subject._putElement = sinon.stub()
|
||
|
|
||
|
this.doc = { _id: doc_id }
|
||
|
return this.subject.addDoc(project_id, folder_id, this.doc, this.callback)
|
||
|
})
|
||
|
|
||
|
it('gets the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('checks the folder exists', function() {
|
||
|
return this.subject._confirmFolder
|
||
|
.calledWith(this.project, folder_id)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('puts the element in mongo', function() {
|
||
|
return this.subject._putElement
|
||
|
.calledWith(this.project, folder_id, this.doc, 'doc', this.callback)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('addFile', function() {
|
||
|
beforeEach(function() {
|
||
|
this.subject._confirmFolder = sinon.stub().yields(folder_id)
|
||
|
this.subject._putElement = sinon.stub()
|
||
|
|
||
|
this.file = { _id: file_id }
|
||
|
return this.subject.addFile(
|
||
|
project_id,
|
||
|
folder_id,
|
||
|
this.file,
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('gets the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('checks the folder exists', function() {
|
||
|
return this.subject._confirmFolder
|
||
|
.calledWith(this.project, folder_id)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('puts the element in mongo', function() {
|
||
|
return this.subject._putElement
|
||
|
.calledWith(this.project, folder_id, this.file, 'file', this.callback)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('replaceFileWithNew', function() {
|
||
|
beforeEach(function() {
|
||
|
this.file = { _id: file_id }
|
||
|
this.path = { mongo: 'file.png' }
|
||
|
this.newFile = { _id: 'new-file-id' }
|
||
|
this.newFile.linkedFileData = this.linkedFileData = { provider: 'url' }
|
||
|
this.newProject = 'new-project'
|
||
|
this.ProjectLocator.findElement = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.file, this.path)
|
||
|
this.ProjectModel.findOneAndUpdate = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.newProject)
|
||
|
this.ProjectModel.update = sinon.stub().yields()
|
||
|
|
||
|
return this.subject.replaceFileWithNew(
|
||
|
project_id,
|
||
|
file_id,
|
||
|
this.newFile,
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('gets the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('finds the existing element', function() {
|
||
|
return this.ProjectLocator.findElement
|
||
|
.calledWith({
|
||
|
project: this.project,
|
||
|
element_id: file_id,
|
||
|
type: 'file'
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('inserts a deletedFile reference for the old file', function() {
|
||
|
return this.ProjectModel.update
|
||
|
.calledWith(
|
||
|
{ _id: project_id },
|
||
|
{
|
||
|
$push: {
|
||
|
deletedFiles: {
|
||
|
_id: file_id,
|
||
|
name: this.file.name,
|
||
|
linkedFileData: this.file.linkedFileData,
|
||
|
hash: this.file.hash,
|
||
|
deletedAt: new Date()
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('increments the project version and sets the rev and created_at', function() {
|
||
|
return this.ProjectModel.findOneAndUpdate
|
||
|
.calledWith(
|
||
|
{ _id: project_id },
|
||
|
{
|
||
|
$inc: { version: 1, 'file.png.rev': 1 },
|
||
|
$set: {
|
||
|
'file.png._id': this.newFile._id,
|
||
|
'file.png.created': new Date(),
|
||
|
'file.png.linkedFileData': this.linkedFileData,
|
||
|
'file.png.hash': this.hash
|
||
|
}
|
||
|
},
|
||
|
{ new: true }
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('calls the callback', function() {
|
||
|
return this.callback
|
||
|
.calledWith(null, this.file, this.project, this.path, this.newProject)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('mkdirp', function() {
|
||
|
beforeEach(function() {
|
||
|
this.parentFolder_id = '1jnjknjk'
|
||
|
this.newFolder = { _id: 'newFolder_id_here' }
|
||
|
this.lastFolder = { _id: '123das', folders: [] }
|
||
|
|
||
|
this.rootFolder = { _id: 'rootFolderId' }
|
||
|
this.project = { _id: project_id, rootFolder: [this.rootFolder] }
|
||
|
|
||
|
this.ProjectGetter.getProjectWithOnlyFolders = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.project)
|
||
|
this.ProjectLocator.findElementByPath = function() {}
|
||
|
sinon.stub(this.ProjectLocator, 'findElementByPath', (options, cb) => {
|
||
|
const { path } = options
|
||
|
this.parentFolder = { _id: 'parentFolder_id_here' }
|
||
|
const lastFolder = path.substring(path.lastIndexOf('/'))
|
||
|
if (lastFolder.indexOf('level1') === -1) {
|
||
|
return cb('level1 is not the last foler ')
|
||
|
} else {
|
||
|
return cb(null, this.parentFolder)
|
||
|
}
|
||
|
})
|
||
|
return (this.subject.addFolder = {
|
||
|
withoutLock: (project_id, parentFolder_id, folderName, callback) => {
|
||
|
return callback(null, { name: folderName }, this.parentFolder_id)
|
||
|
}
|
||
|
})
|
||
|
})
|
||
|
|
||
|
it('should return the root folder if the path is just a slash', function(done) {
|
||
|
const path = '/'
|
||
|
return this.subject.mkdirp(
|
||
|
project_id,
|
||
|
path,
|
||
|
{},
|
||
|
(err, folders, lastFolder) => {
|
||
|
lastFolder.should.deep.equal(this.rootFolder)
|
||
|
assert.equal(lastFolder.parentFolder_id, undefined)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should make just one folder', function(done) {
|
||
|
const path = '/differentFolder/'
|
||
|
return this.subject.mkdirp(
|
||
|
project_id,
|
||
|
path,
|
||
|
{},
|
||
|
(err, folders, lastFolder) => {
|
||
|
folders.length.should.equal(1)
|
||
|
lastFolder.name.should.equal('differentFolder')
|
||
|
lastFolder.parentFolder_id.should.equal(this.parentFolder_id)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should make the final folder in path if it doesnt exist with one level', function(done) {
|
||
|
const path = 'level1/level2'
|
||
|
return this.subject.mkdirp(
|
||
|
project_id,
|
||
|
path,
|
||
|
{},
|
||
|
(err, folders, lastFolder) => {
|
||
|
folders.length.should.equal(1)
|
||
|
lastFolder.name.should.equal('level2')
|
||
|
lastFolder.parentFolder_id.should.equal(this.parentFolder_id)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should make the final folder in path if it doesnt exist with mutliple levels', function(done) {
|
||
|
const path = 'level1/level2/level3'
|
||
|
|
||
|
return this.subject.mkdirp(
|
||
|
project_id,
|
||
|
path,
|
||
|
{},
|
||
|
(err, folders, lastFolder) => {
|
||
|
folders.length.should.equal(2)
|
||
|
folders[0].name.should.equal('level2')
|
||
|
folders[0].parentFolder_id.should.equal(this.parentFolder_id)
|
||
|
lastFolder.name.should.equal('level3')
|
||
|
lastFolder.parentFolder_id.should.equal(this.parentFolder_id)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should work with slashes either side', function(done) {
|
||
|
const path = '/level1/level2/level3/'
|
||
|
|
||
|
return this.subject.mkdirp(
|
||
|
project_id,
|
||
|
path,
|
||
|
{},
|
||
|
(err, folders, lastFolder) => {
|
||
|
folders.length.should.equal(2)
|
||
|
folders[0].name.should.equal('level2')
|
||
|
folders[0].parentFolder_id.should.equal(this.parentFolder_id)
|
||
|
lastFolder.name.should.equal('level3')
|
||
|
lastFolder.parentFolder_id.should.equal(this.parentFolder_id)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should use a case-insensitive match by default', function(done) {
|
||
|
const path = '/differentFolder/'
|
||
|
return this.subject.mkdirp(
|
||
|
project_id,
|
||
|
path,
|
||
|
{},
|
||
|
(err, folders, lastFolder) => {
|
||
|
this.ProjectLocator.findElementByPath
|
||
|
.calledWithMatch({ exactCaseMatch: undefined })
|
||
|
.should.equal(true)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
return it('should use a case-sensitive match if exactCaseMatch option is set', function(done) {
|
||
|
const path = '/differentFolder/'
|
||
|
return this.subject.mkdirp(
|
||
|
project_id,
|
||
|
path,
|
||
|
{ exactCaseMatch: true },
|
||
|
(err, folders, lastFolder) => {
|
||
|
this.ProjectLocator.findElementByPath
|
||
|
.calledWithMatch({ exactCaseMatch: true })
|
||
|
.should.equal(true)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('moveEntity', function() {
|
||
|
beforeEach(function() {
|
||
|
this.pathAfterMove = {
|
||
|
fileSystem: '/somewhere/else.txt'
|
||
|
}
|
||
|
|
||
|
this.ProjectEntityHandler.getAllEntitiesFromProject = sinon.stub()
|
||
|
this.ProjectEntityHandler.getAllEntitiesFromProject
|
||
|
.onFirstCall()
|
||
|
.yields(
|
||
|
null,
|
||
|
(this.oldDocs = ['old-doc']),
|
||
|
(this.oldFiles = ['old-file'])
|
||
|
)
|
||
|
this.ProjectEntityHandler.getAllEntitiesFromProject
|
||
|
.onSecondCall()
|
||
|
.yields(
|
||
|
null,
|
||
|
(this.newDocs = ['new-doc']),
|
||
|
(this.newFiles = ['new-file'])
|
||
|
)
|
||
|
|
||
|
this.doc = { lines: ['1234', '312343d'], rev: '1234' }
|
||
|
this.path = {
|
||
|
mongo: 'folders[0]',
|
||
|
fileSystem: '/old_folder/somewhere.txt'
|
||
|
}
|
||
|
this.newProject = 'new-project'
|
||
|
this.ProjectLocator.findElement = sinon
|
||
|
.stub()
|
||
|
.withArgs({
|
||
|
project: this.project,
|
||
|
element_id: this.docId,
|
||
|
type: 'docs'
|
||
|
})
|
||
|
.yields(null, this.doc, this.path)
|
||
|
|
||
|
this.subject._checkValidMove = sinon.stub().yields()
|
||
|
|
||
|
this.subject._removeElementFromMongoArray = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.newProject)
|
||
|
this.subject._putElement = sinon
|
||
|
.stub()
|
||
|
.yields(null, { path: this.pathAfterMove }, this.newProject)
|
||
|
|
||
|
return this.subject.moveEntity(
|
||
|
project_id,
|
||
|
doc_id,
|
||
|
folder_id,
|
||
|
'docs',
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should get the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should find the doc to move', function() {
|
||
|
return this.ProjectLocator.findElement
|
||
|
.calledWith({ element_id: doc_id, type: 'docs', project: this.project })
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should check this is a valid move', function() {
|
||
|
return this.subject._checkValidMove
|
||
|
.calledWith(this.project, 'docs', this.doc, this.path, folder_id)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should put the element in the new folder', function() {
|
||
|
return this.subject._putElement
|
||
|
.calledWith(this.project, folder_id, this.doc, 'docs')
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should remove the element from its current position', function() {
|
||
|
return this.subject._removeElementFromMongoArray
|
||
|
.calledWith(this.ProjectModel, project_id, this.path.mongo, doc_id)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should remove the element from its current position after putting the element in the new folder', function() {
|
||
|
return this.subject._removeElementFromMongoArray
|
||
|
.calledAfter(this.subject._putElement)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('calls the callback', function() {
|
||
|
const changes = {
|
||
|
oldDocs: this.oldDocs,
|
||
|
newDocs: this.newDocs,
|
||
|
oldFiles: this.oldFiles,
|
||
|
newFiles: this.newFiles,
|
||
|
newProject: this.newProject
|
||
|
}
|
||
|
return this.callback
|
||
|
.calledWith(
|
||
|
null,
|
||
|
this.project,
|
||
|
this.path.fileSystem,
|
||
|
this.pathAfterMove.fileSystem,
|
||
|
this.doc.rev,
|
||
|
changes
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('moveEntity must refuse to move the folder to a subfolder of itself', function() {
|
||
|
beforeEach(function() {
|
||
|
this.pathAfterMove = {
|
||
|
fileSystem: '/somewhere/else.txt'
|
||
|
}
|
||
|
|
||
|
this.doc = { lines: ['1234', '312343d'], rev: '1234' }
|
||
|
this.path = {
|
||
|
mongo: 'folders[0]',
|
||
|
fileSystem: '/old_folder/somewhere.txt'
|
||
|
}
|
||
|
this.newProject = 'new-project'
|
||
|
this.ProjectLocator.findElement = sinon
|
||
|
.stub()
|
||
|
.withArgs({
|
||
|
project: this.project,
|
||
|
element_id: this.docId,
|
||
|
type: 'docs'
|
||
|
})
|
||
|
.yields(null, this.doc, this.path)
|
||
|
|
||
|
// return an error when moving a folder to a subfolder of itself
|
||
|
this.subject._checkValidMove = sinon.stub().yields(new Error())
|
||
|
|
||
|
this.subject._removeElementFromMongoArray = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.project)
|
||
|
this.subject._putElement = sinon
|
||
|
.stub()
|
||
|
.yields(null, { path: this.pathAfterMove }, this.newProject)
|
||
|
|
||
|
return this.subject.moveEntity(
|
||
|
project_id,
|
||
|
doc_id,
|
||
|
folder_id,
|
||
|
'docs',
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should get the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should find the doc to move', function() {
|
||
|
return this.ProjectLocator.findElement
|
||
|
.calledWith({ element_id: doc_id, type: 'docs', project: this.project })
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should check this is an invalid move', function() {
|
||
|
return this.subject._checkValidMove
|
||
|
.calledWith(this.project, 'docs', this.doc, this.path, folder_id)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should not put the element in the new folder', function() {
|
||
|
return this.subject._putElement.called.should.equal(false)
|
||
|
})
|
||
|
|
||
|
it('should not remove the element from its current position', function() {
|
||
|
return this.subject._removeElementFromMongoArray.called.should.equal(
|
||
|
false
|
||
|
)
|
||
|
})
|
||
|
|
||
|
return it('calls the callback with an error', function() {
|
||
|
return this.callback.calledWith(new Error()).should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('deleteEntity', function() {
|
||
|
beforeEach(function() {
|
||
|
this.path = { mongo: 'mongo.path', fileSystem: '/file/system/path' }
|
||
|
this.doc = { _id: doc_id }
|
||
|
this.ProjectLocator.findElement = sinon
|
||
|
.stub()
|
||
|
.callsArgWith(1, null, this.doc, this.path)
|
||
|
this.subject._removeElementFromMongoArray = sinon.stub().yields()
|
||
|
return this.subject.deleteEntity(project_id, doc_id, 'doc', this.callback)
|
||
|
})
|
||
|
|
||
|
it('should get the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should find the element', function() {
|
||
|
return this.ProjectLocator.findElement
|
||
|
.calledWith({
|
||
|
project: this.project,
|
||
|
element_id: this.doc._id,
|
||
|
type: 'doc'
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should remove the element from the database', function() {
|
||
|
return this.subject._removeElementFromMongoArray
|
||
|
.calledWith(
|
||
|
this.ProjectModel,
|
||
|
project_id,
|
||
|
this.path.mongo,
|
||
|
this.doc._id
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('calls the callbck', function() {
|
||
|
return this.callback
|
||
|
.calledWith(null, this.doc, this.path, this.project)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('renameEntity', function() {
|
||
|
beforeEach(function() {
|
||
|
this.newName = 'new.tex'
|
||
|
this.path = { mongo: 'mongo.path', fileSystem: '/old.tex' }
|
||
|
|
||
|
this.project = {
|
||
|
_id: ObjectId(project_id),
|
||
|
rootFolder: [{ _id: ObjectId() }]
|
||
|
}
|
||
|
this.doc = { _id: doc_id, name: 'old.tex', rev: 1 }
|
||
|
this.folder = { _id: folder_id }
|
||
|
this.newProject = 'new-project'
|
||
|
|
||
|
this.ProjectGetter.getProjectWithoutLock = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.project)
|
||
|
|
||
|
this.ProjectEntityHandler.getAllEntitiesFromProject = sinon.stub()
|
||
|
this.ProjectEntityHandler.getAllEntitiesFromProject
|
||
|
.onFirstCall()
|
||
|
.yields(
|
||
|
null,
|
||
|
(this.oldDocs = ['old-doc']),
|
||
|
(this.oldFiles = ['old-file'])
|
||
|
)
|
||
|
this.ProjectEntityHandler.getAllEntitiesFromProject
|
||
|
.onSecondCall()
|
||
|
.yields(
|
||
|
null,
|
||
|
(this.newDocs = ['new-doc']),
|
||
|
(this.newFiles = ['new-file'])
|
||
|
)
|
||
|
|
||
|
this.ProjectLocator.findElement = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.doc, this.path, this.folder)
|
||
|
this.subject._checkValidElementName = sinon.stub().yields()
|
||
|
this.ProjectModel.findOneAndUpdate = sinon
|
||
|
.stub()
|
||
|
.callsArgWith(3, null, this.newProject)
|
||
|
|
||
|
return this.subject.renameEntity(
|
||
|
project_id,
|
||
|
doc_id,
|
||
|
'doc',
|
||
|
this.newName,
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should get the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should find the doc', function() {
|
||
|
return this.ProjectLocator.findElement
|
||
|
.calledWith({ element_id: doc_id, type: 'doc', project: this.project })
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should check the new name is valid', function() {
|
||
|
return this.subject._checkValidElementName
|
||
|
.calledWith(this.folder, this.newName)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('should update the doc name', function() {
|
||
|
return this.ProjectModel.findOneAndUpdate
|
||
|
.calledWith(
|
||
|
{ _id: project_id },
|
||
|
{ $set: { 'mongo.path.name': this.newName }, $inc: { version: 1 } },
|
||
|
{ new: true }
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('calls the callback', function() {
|
||
|
const changes = {
|
||
|
oldDocs: this.oldDocs,
|
||
|
newDocs: this.newDocs,
|
||
|
oldFiles: this.oldFiles,
|
||
|
newFiles: this.newFiles,
|
||
|
newProject: this.newProject
|
||
|
}
|
||
|
return this.callback
|
||
|
.calledWith(
|
||
|
null,
|
||
|
this.project,
|
||
|
'/old.tex',
|
||
|
'/new.tex',
|
||
|
this.doc.rev,
|
||
|
changes
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('addFolder', function() {
|
||
|
beforeEach(function() {
|
||
|
this.folderName = 'folder1234'
|
||
|
this.ProjectGetter.getProjectWithOnlyFolders = sinon
|
||
|
.stub()
|
||
|
.callsArgWith(1, null, this.project)
|
||
|
this.subject._confirmFolder = sinon.stub().yields(folder_id)
|
||
|
this.subject._putElement = sinon.stub().yields()
|
||
|
|
||
|
return this.subject.addFolder(
|
||
|
project_id,
|
||
|
folder_id,
|
||
|
this.folderName,
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('gets the project', function() {
|
||
|
return this.ProjectGetter.getProjectWithoutLock
|
||
|
.calledWith(project_id, {
|
||
|
rootFolder: true,
|
||
|
name: true,
|
||
|
overleaf: true
|
||
|
})
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('checks the parent folder exists', function() {
|
||
|
return this.subject._confirmFolder
|
||
|
.calledWith(this.project, folder_id)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
it('puts the element in mongo', function() {
|
||
|
const folderMatcher = sinon.match(folder => {
|
||
|
return folder.name === this.folderName
|
||
|
})
|
||
|
|
||
|
return this.subject._putElement
|
||
|
.calledWithMatch(this.project, folder_id, folderMatcher, 'folder')
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('calls the callback', function() {
|
||
|
const folderMatcher = sinon.match(folder => {
|
||
|
return folder.name === this.folderName
|
||
|
})
|
||
|
|
||
|
return this.callback
|
||
|
.calledWithMatch(null, folderMatcher, folder_id)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('_removeElementFromMongoArray ', function() {
|
||
|
beforeEach(function() {
|
||
|
this.mongoPath = 'folders[0].folders[5]'
|
||
|
this.id = '12344'
|
||
|
this.entityId = '5678'
|
||
|
this.ProjectModel.update = sinon.stub().yields()
|
||
|
this.ProjectModel.findOneAndUpdate = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.project)
|
||
|
return this.subject._removeElementFromMongoArray(
|
||
|
this.ProjectModel,
|
||
|
this.id,
|
||
|
this.mongoPath,
|
||
|
this.entityId,
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should pull', function() {
|
||
|
return this.ProjectModel.findOneAndUpdate
|
||
|
.calledWith(
|
||
|
{ _id: this.id },
|
||
|
{
|
||
|
$pull: { 'folders[0]': { _id: this.entityId } },
|
||
|
$inc: { version: 1 }
|
||
|
},
|
||
|
{ new: true }
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('should call the callback', function() {
|
||
|
return this.callback.calledWith(null, this.project).should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('_countElements', function() {
|
||
|
beforeEach(function() {
|
||
|
return (this.project = {
|
||
|
_id: project_id,
|
||
|
rootFolder: [
|
||
|
{
|
||
|
docs: [{ _id: 123 }, { _id: 345 }],
|
||
|
fileRefs: [{ _id: 123 }, { _id: 345 }, { _id: 456 }],
|
||
|
folders: [
|
||
|
{
|
||
|
docs: [{ _id: 123 }, { _id: 345 }, { _id: 456 }],
|
||
|
fileRefs: {},
|
||
|
folders: [
|
||
|
{
|
||
|
docs: [{ _id: 1234 }],
|
||
|
fileRefs: [{ _id: 23123 }, { _id: 123213 }, { _id: 2312 }],
|
||
|
folders: [
|
||
|
{
|
||
|
docs: [{ _id: 321321 }, { _id: 123213 }],
|
||
|
fileRefs: [{ _id: 312321 }],
|
||
|
folders: []
|
||
|
}
|
||
|
]
|
||
|
}
|
||
|
]
|
||
|
},
|
||
|
{
|
||
|
docs: [{ _id: 123 }, { _id: 32131 }],
|
||
|
fileRefs: [],
|
||
|
folders: [
|
||
|
{
|
||
|
docs: [{ _id: 3123 }],
|
||
|
fileRefs: [
|
||
|
{ _id: 321321 },
|
||
|
{ _id: 321321 },
|
||
|
{ _id: 313122 }
|
||
|
],
|
||
|
folders: 0
|
||
|
}
|
||
|
]
|
||
|
}
|
||
|
]
|
||
|
}
|
||
|
]
|
||
|
})
|
||
|
})
|
||
|
|
||
|
it('should return the correct number', function() {
|
||
|
return expect(this.subject._countElements(this.project)).to.equal(26)
|
||
|
})
|
||
|
|
||
|
it('should deal with null folders', function() {
|
||
|
this.project.rootFolder[0].folders[0].folders = undefined
|
||
|
return expect(this.subject._countElements(this.project)).to.equal(17)
|
||
|
})
|
||
|
|
||
|
it('should deal with null docs', function() {
|
||
|
this.project.rootFolder[0].folders[0].docs = undefined
|
||
|
return expect(this.subject._countElements(this.project)).to.equal(23)
|
||
|
})
|
||
|
|
||
|
return it('should deal with null fileRefs', function() {
|
||
|
this.project.rootFolder[0].folders[0].folders[0].fileRefs = undefined
|
||
|
return expect(this.subject._countElements(this.project)).to.equal(23)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('_putElement', function() {
|
||
|
beforeEach(function() {
|
||
|
this.project = {
|
||
|
_id: project_id,
|
||
|
rootFolder: [{ _id: ObjectId() }]
|
||
|
}
|
||
|
this.folder = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'someFolder',
|
||
|
docs: [{ name: 'another-doc.tex' }],
|
||
|
fileRefs: [{ name: 'another-file.tex' }],
|
||
|
folders: [{ name: 'another-folder' }]
|
||
|
}
|
||
|
this.doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'new.tex'
|
||
|
}
|
||
|
this.path = { mongo: 'mongo.path', fileSystem: '/file/system/old.tex' }
|
||
|
this.ProjectLocator.findElement = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.folder, this.path)
|
||
|
return (this.ProjectModel.findOneAndUpdate = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.project))
|
||
|
})
|
||
|
|
||
|
return describe('updating the project', function() {
|
||
|
it('should use the correct mongo path', function(done) {
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
this.doc,
|
||
|
'docs',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.args[0][0]._id.should.equal(
|
||
|
this.project._id
|
||
|
)
|
||
|
assert.deepEqual(
|
||
|
this.ProjectModel.findOneAndUpdate.args[0][1].$push[
|
||
|
this.path.mongo + '.docs'
|
||
|
],
|
||
|
this.doc
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should return the project in the callback', function(done) {
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
this.doc,
|
||
|
'docs',
|
||
|
(err, path, project) => {
|
||
|
assert.equal(project, this.project)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should add an s onto the type if not included', function(done) {
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
this.doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
assert.deepEqual(
|
||
|
this.ProjectModel.findOneAndUpdate.args[0][1].$push[
|
||
|
this.path.mongo + '.docs'
|
||
|
],
|
||
|
this.doc
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should not call update if element is null', function(done) {
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
null,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should default to root folder insert', function(done) {
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
null,
|
||
|
this.doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectLocator.findElement.args[0][0].element_id.should.equal(
|
||
|
this.project.rootFolder[0]._id
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should error if the element has no _id', function(done) {
|
||
|
const doc = { name: 'something' }
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should error if element name contains invalid characters', function(done) {
|
||
|
const doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'something*bad'
|
||
|
}
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
err.should.deep.equal(
|
||
|
new Errors.InvalidNameError('invalid element name')
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should error if element name is too long', function(done) {
|
||
|
const doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: new Array(200).join('long-') + 'something'
|
||
|
}
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
err.should.deep.equal(
|
||
|
new Errors.InvalidNameError('invalid element name')
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should error if the folder name is too long', function(done) {
|
||
|
this.path = {
|
||
|
mongo: 'mongo.path',
|
||
|
fileSystem: new Array(200).join('subdir/') + 'foo'
|
||
|
}
|
||
|
this.ProjectLocator.findElement.callsArgWith(
|
||
|
1,
|
||
|
null,
|
||
|
this.folder,
|
||
|
this.path
|
||
|
)
|
||
|
const doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'something'
|
||
|
}
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder._id,
|
||
|
doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
err.should.deep.equal(new Errors.InvalidNameError('path too long'))
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should error if a document already exists with the same name', function(done) {
|
||
|
const doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'another-doc.tex'
|
||
|
}
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder,
|
||
|
doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
err.should.deep.equal(
|
||
|
new Errors.InvalidNameError('file already exists')
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should error if a file already exists with the same name', function(done) {
|
||
|
const doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'another-file.tex'
|
||
|
}
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder,
|
||
|
doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
err.should.deep.equal(
|
||
|
new Errors.InvalidNameError('file already exists')
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
return it('should error if a folder already exists with the same name', function(done) {
|
||
|
const doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'another-folder'
|
||
|
}
|
||
|
return this.subject._putElement(
|
||
|
this.project,
|
||
|
this.folder,
|
||
|
doc,
|
||
|
'doc',
|
||
|
err => {
|
||
|
this.ProjectModel.findOneAndUpdate.called.should.equal(false)
|
||
|
err.should.deep.equal(
|
||
|
new Errors.InvalidNameError('file already exists')
|
||
|
)
|
||
|
return done()
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('_checkValidElementName', function() {
|
||
|
beforeEach(function() {
|
||
|
return (this.folder = {
|
||
|
docs: [{ name: 'doc_name' }],
|
||
|
fileRefs: [{ name: 'file_name' }],
|
||
|
folders: [{ name: 'folder_name' }]
|
||
|
})
|
||
|
})
|
||
|
|
||
|
it('returns an error if name matches any doc name', function() {
|
||
|
return this.subject._checkValidElementName(this.folder, 'doc_name', err =>
|
||
|
expect(err).to.deep.equal(
|
||
|
new Errors.InvalidNameError('file already exists')
|
||
|
)
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('returns an error if name matches any file name', function() {
|
||
|
return this.subject._checkValidElementName(
|
||
|
this.folder,
|
||
|
'file_name',
|
||
|
err =>
|
||
|
expect(err).to.deep.equal(
|
||
|
new Errors.InvalidNameError('file already exists')
|
||
|
)
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('returns an error if name matches any folder name', function() {
|
||
|
return this.subject._checkValidElementName(
|
||
|
this.folder,
|
||
|
'folder_name',
|
||
|
err =>
|
||
|
expect(err).to.deep.equal(
|
||
|
new Errors.InvalidNameError('file already exists')
|
||
|
)
|
||
|
)
|
||
|
})
|
||
|
|
||
|
return it('returns nothing if name is valid', function() {
|
||
|
return this.subject._checkValidElementName(
|
||
|
this.folder,
|
||
|
'unique_name',
|
||
|
err => expect(err).to.be.undefined
|
||
|
)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
describe('_checkValidMove', function() {
|
||
|
beforeEach(function() {
|
||
|
this.destFolder = { _id: folder_id }
|
||
|
this.destFolderPath = { fileSystem: '/foo/bar' }
|
||
|
this.ProjectLocator.findElement = sinon
|
||
|
.stub()
|
||
|
.yields(null, this.destFolder, this.destFolderPath)
|
||
|
return (this.subject._checkValidElementName = sinon.stub().yields())
|
||
|
})
|
||
|
|
||
|
it('checks the element name is valid', function() {
|
||
|
this.doc = { _id: doc_id, name: 'doc_name' }
|
||
|
return this.subject._checkValidMove(
|
||
|
this.project,
|
||
|
'doc',
|
||
|
this.doc,
|
||
|
{ fileSystem: '/main.tex' },
|
||
|
this.destFolder._id,
|
||
|
err => {
|
||
|
expect(err).to.be.undefined
|
||
|
return this.subject._checkValidElementName
|
||
|
.calledWith(this.destFolder, this.doc.name)
|
||
|
.should.equal(true)
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
|
||
|
return it('returns an error if trying to move a folder inside itself', function() {
|
||
|
const folder = { name: 'folder_name' }
|
||
|
return this.subject._checkValidMove(
|
||
|
this.project,
|
||
|
'folder',
|
||
|
folder,
|
||
|
{ fileSystem: '/foo' },
|
||
|
this.destFolder._id,
|
||
|
err => {
|
||
|
return expect(err).to.deep.equal(
|
||
|
new Errors.InvalidNameError(
|
||
|
'destination folder is a child folder of me'
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
)
|
||
|
})
|
||
|
})
|
||
|
|
||
|
return describe('_insertDeletedDocReference', function() {
|
||
|
beforeEach(function() {
|
||
|
this.doc = {
|
||
|
_id: ObjectId(),
|
||
|
name: 'test.tex'
|
||
|
}
|
||
|
this.callback = sinon.stub()
|
||
|
this.ProjectModel.update = sinon.stub().yields()
|
||
|
return this.subject._insertDeletedDocReference(
|
||
|
project_id,
|
||
|
this.doc,
|
||
|
this.callback
|
||
|
)
|
||
|
})
|
||
|
|
||
|
it('should insert the doc into deletedDocs', function() {
|
||
|
return this.ProjectModel.update
|
||
|
.calledWith(
|
||
|
{
|
||
|
_id: project_id
|
||
|
},
|
||
|
{
|
||
|
$push: {
|
||
|
deletedDocs: {
|
||
|
_id: this.doc._id,
|
||
|
name: this.doc.name,
|
||
|
deletedAt: new Date()
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
)
|
||
|
.should.equal(true)
|
||
|
})
|
||
|
|
||
|
return it('should call the callback', function() {
|
||
|
return this.callback.called.should.equal(true)
|
||
|
})
|
||
|
})
|
||
|
})
|