mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-16 02:52:31 -04:00
597 lines
20 KiB
CoffeeScript
597 lines
20 KiB
CoffeeScript
chai = require('chai')
|
|
expect = chai.expect
|
|
assert = require('chai').assert
|
|
should = chai.should()
|
|
sinon = require 'sinon'
|
|
tk = require("timekeeper")
|
|
modulePath = "../../../../app/js/Features/Project/ProjectEntityMongoUpdateHandler"
|
|
Errors = require "../../../../app/js/Features/Errors/Errors"
|
|
ObjectId = require("mongoose").Types.ObjectId
|
|
SandboxedModule = require('sandboxed-module')
|
|
|
|
describe 'ProjectEntityMongoUpdateHandler', ->
|
|
project_id = '4eecb1c1bffa66588e0000a1'
|
|
doc_id = '4eecb1c1bffa66588e0000a2'
|
|
file_id = '4eecb1c1bffa66588e0000a3'
|
|
folder_id = "4eecaffcbffa66588e000008"
|
|
|
|
beforeEach ->
|
|
@FolderModel = class Folder
|
|
constructor:(options)->
|
|
{@name} = options
|
|
@._id = "folder_id"
|
|
|
|
@docName = "doc-name"
|
|
@fileName = "something.jpg"
|
|
@project = _id: project_id, name: 'project name'
|
|
|
|
@callback = sinon.stub()
|
|
|
|
tk.freeze(Date.now())
|
|
@subject = SandboxedModule.require modulePath, requires:
|
|
'logger-sharelatex': @logger = {log:sinon.stub(), error: sinon.stub(), err:->}
|
|
"settings-sharelatex":@settings = {
|
|
maxEntitiesPerProject: 100
|
|
}
|
|
"../Cooldown/CooldownManager": @CooldownManager = {}
|
|
'../../models/Folder': Folder:@FolderModel
|
|
"../../infrastructure/LockManager":@LockManager =
|
|
runWithLock:
|
|
sinon.spy((namespace, id, runner, callback) -> runner(callback))
|
|
'../../models/Project': Project:@ProjectModel = {}
|
|
'./ProjectEntityHandler': @ProjectEntityHandler = {}
|
|
'./ProjectLocator': @ProjectLocator = {}
|
|
"./ProjectGetter": @ProjectGetter =
|
|
getProjectWithoutLock: sinon.stub().yields(null, @project)
|
|
|
|
afterEach ->
|
|
tk.reset()
|
|
|
|
describe 'addDoc', ->
|
|
beforeEach ->
|
|
@subject._confirmFolder = sinon.stub().yields(folder_id)
|
|
@subject._putElement = sinon.stub()
|
|
|
|
@doc = _id: doc_id
|
|
@subject.addDoc project_id, folder_id, @doc, @callback
|
|
|
|
it 'gets the project', ->
|
|
@ProjectGetter.getProjectWithoutLock
|
|
.calledWith(project_id, {rootFolder:true, name: true})
|
|
.should.equal true
|
|
|
|
it 'checks the folder exists', ->
|
|
@subject._confirmFolder
|
|
.calledWith(@project, folder_id)
|
|
.should.equal true
|
|
|
|
it 'puts the element in mongo', ->
|
|
@subject._putElement
|
|
.calledWith(@project, folder_id, @doc, 'doc', @callback)
|
|
.should.equal true
|
|
|
|
describe 'addFile', ->
|
|
beforeEach ->
|
|
@subject._confirmFolder = sinon.stub().yields(folder_id)
|
|
@subject._putElement = sinon.stub()
|
|
|
|
@file = _id: file_id
|
|
@subject.addFile project_id, folder_id, @file, @callback
|
|
|
|
it 'gets the project', ->
|
|
@ProjectGetter.getProjectWithoutLock
|
|
.calledWith(project_id, {rootFolder:true, name: true})
|
|
.should.equal true
|
|
|
|
it 'checks the folder exists', ->
|
|
@subject._confirmFolder
|
|
.calledWith(@project, folder_id)
|
|
.should.equal true
|
|
|
|
it 'puts the element in mongo', ->
|
|
@subject._putElement
|
|
.calledWith(@project, folder_id, @file, 'file', @callback)
|
|
.should.equal true
|
|
|
|
describe 'replaceFile', ->
|
|
beforeEach ->
|
|
@file = _id: file_id
|
|
@path = mongo: 'file.png'
|
|
@ProjectLocator.findElement = sinon.stub().yields(null, @file, @path)
|
|
@ProjectModel.update = sinon.stub().yields()
|
|
|
|
@subject.replaceFile project_id, file_id, @callback
|
|
|
|
it 'gets the project', ->
|
|
@ProjectGetter.getProjectWithoutLock
|
|
.calledWith(project_id, {rootFolder:true, name: true})
|
|
.should.equal true
|
|
|
|
it 'finds the element', ->
|
|
@ProjectLocator.findElement
|
|
.calledWith({ @project, element_id: file_id, type: 'file' })
|
|
.should.equal true
|
|
|
|
it 'increments the rev and sets the created_at', ->
|
|
@ProjectModel.update
|
|
.calledWith(
|
|
{ _id: project_id },
|
|
{
|
|
'$inc': { 'file.png.rev': 1 }
|
|
'$set': { 'file.png.created': new Date() }
|
|
}
|
|
{}
|
|
)
|
|
.should.equal true
|
|
|
|
it 'calls the callback', ->
|
|
@callback.calledWith(null, @file, @project, @path).should.equal true
|
|
|
|
describe 'mkdirp', ->
|
|
beforeEach ->
|
|
@parentFolder_id = "1jnjknjk"
|
|
@newFolder = {_id:"newFolder_id_here"}
|
|
@lastFolder = {_id:"123das", folders:[]}
|
|
|
|
@rootFolder = {_id: "rootFolderId" }
|
|
@project = _id: project_id, rootFolder: [@rootFolder]
|
|
|
|
@ProjectGetter.getProjectWithOnlyFolders = sinon.stub().yields(null, @project)
|
|
@ProjectLocator.findElementByPath = (options, cb) =>
|
|
{path} = options
|
|
@parentFolder = {_id:"parentFolder_id_here"}
|
|
lastFolder = path.substring(path.lastIndexOf("/"))
|
|
if lastFolder.indexOf("level1") == -1
|
|
cb "level1 is not the last foler "
|
|
else
|
|
cb null, @parentFolder
|
|
@subject.addFolder =
|
|
withoutLock: (project_id, parentFolder_id, folderName, callback) =>
|
|
callback null, {name:folderName}, @parentFolder_id
|
|
|
|
it 'should return the root folder if the path is just a slash', (done)->
|
|
path = "/"
|
|
@subject.mkdirp project_id, path, (err, folders, lastFolder)=>
|
|
lastFolder.should.deep.equal @rootFolder
|
|
assert.equal lastFolder.parentFolder_id, undefined
|
|
done()
|
|
|
|
it 'should make just one folder', (done)->
|
|
path = "/differentFolder/"
|
|
@subject.mkdirp project_id, path, (err, folders, lastFolder)=>
|
|
folders.length.should.equal 1
|
|
lastFolder.name.should.equal "differentFolder"
|
|
lastFolder.parentFolder_id.should.equal @parentFolder_id
|
|
done()
|
|
|
|
it 'should make the final folder in path if it doesnt exist with one level', (done)->
|
|
path = "level1/level2"
|
|
@subject.mkdirp project_id, path, (err, folders, lastFolder)=>
|
|
folders.length.should.equal 1
|
|
lastFolder.name.should.equal "level2"
|
|
lastFolder.parentFolder_id.should.equal @parentFolder_id
|
|
done()
|
|
|
|
it 'should make the final folder in path if it doesnt exist with mutliple levels', (done)->
|
|
path = "level1/level2/level3"
|
|
|
|
@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 @parentFolder_id
|
|
lastFolder.name.should.equal "level3"
|
|
lastFolder.parentFolder_id.should.equal @parentFolder_id
|
|
done()
|
|
|
|
it 'should work with slashes either side', (done)->
|
|
path = "/level1/level2/level3/"
|
|
|
|
@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 @parentFolder_id
|
|
lastFolder.name.should.equal "level3"
|
|
lastFolder.parentFolder_id.should.equal @parentFolder_id
|
|
done()
|
|
|
|
describe 'moveEntity', ->
|
|
beforeEach ->
|
|
@pathAfterMove = {
|
|
fileSystem: "/somewhere/else.txt"
|
|
}
|
|
|
|
@ProjectEntityHandler.getAllEntitiesFromProject = sinon.stub()
|
|
@ProjectEntityHandler.getAllEntitiesFromProject
|
|
.onFirstCall()
|
|
.yields(null, @oldDocs = ['old-doc'], @oldFiles = ['old-file'])
|
|
@ProjectEntityHandler.getAllEntitiesFromProject
|
|
.onSecondCall()
|
|
.yields(null, @newDocs = ['new-doc'], @newFiles = ['new-file'])
|
|
|
|
@doc = {lines:["1234","312343d"], rev: "1234"}
|
|
@path = { mongo:"folders[0]", fileSystem:"/old_folder/somewhere.txt" }
|
|
@ProjectLocator.findElement = sinon.stub()
|
|
.withArgs({@project, element_id: @docId, type: 'docs'})
|
|
.yields(null, @doc, @path)
|
|
|
|
@subject._checkValidMove = sinon.stub().yields()
|
|
|
|
@subject._removeElementFromMongoArray = sinon.stub().yields(null, @project)
|
|
@subject._putElement = sinon.stub().yields(null, path: @pathAfterMove)
|
|
|
|
@subject.moveEntity project_id, doc_id, folder_id, "docs", @callback
|
|
|
|
it 'should get the project', ->
|
|
@ProjectGetter.getProjectWithoutLock
|
|
.calledWith(project_id, {rootFolder:true, name:true})
|
|
.should.equal true
|
|
|
|
it 'should find the doc to move', ->
|
|
@ProjectLocator.findElement
|
|
.calledWith({element_id: doc_id, type: "docs", project: @project })
|
|
.should.equal true
|
|
|
|
it 'should check this is a valid move', ->
|
|
@subject._checkValidMove
|
|
.calledWith(@project, 'docs', @doc, @path, folder_id)
|
|
.should.equal true
|
|
|
|
it 'should remove the element from its current position', ->
|
|
@subject._removeElementFromMongoArray
|
|
.calledWith(@ProjectModel, project_id, @path.mongo)
|
|
.should.equal true
|
|
|
|
it "should put the element back in the new folder", ->
|
|
@subject._putElement
|
|
.calledWith(@project, folder_id, @doc, "docs")
|
|
.should.equal true
|
|
|
|
it "calls the callback", ->
|
|
changes = { @oldDocs, @newDocs, @oldFiles, @newFiles }
|
|
@callback.calledWith(
|
|
null, @project.name, @path.fileSystem, @pathAfterMove.fileSystem, @doc.rev, changes
|
|
).should.equal true
|
|
|
|
describe 'deleteEntity', ->
|
|
beforeEach ->
|
|
@path = mongo: "mongo.path", fileSystem: "/file/system/path"
|
|
@doc = _id: doc_id
|
|
@ProjectLocator.findElement = sinon.stub().callsArgWith(1, null, @doc, @path)
|
|
@subject._removeElementFromMongoArray = sinon.stub().yields()
|
|
@subject.deleteEntity project_id, doc_id, 'doc', @callback
|
|
|
|
it "should get the project", ->
|
|
@ProjectGetter.getProjectWithoutLock
|
|
.calledWith(project_id, {name:true, rootFolder:true})
|
|
.should.equal true
|
|
|
|
it "should find the element", ->
|
|
@ProjectLocator.findElement
|
|
.calledWith({@project, element_id: @doc._id, type: 'doc'})
|
|
.should.equal true
|
|
|
|
it "should remove the element from the database", ->
|
|
@subject._removeElementFromMongoArray
|
|
.calledWith(@ProjectModel, project_id, @path.mongo)
|
|
.should.equal true
|
|
|
|
it "calls the callbck", ->
|
|
@callback.calledWith(null, @doc, @path, @project).should.equal true
|
|
|
|
describe "renameEntity", ->
|
|
beforeEach ->
|
|
@newName = "new.tex"
|
|
@path = mongo: "mongo.path", fileSystem: "/old.tex"
|
|
|
|
@project =
|
|
_id: ObjectId(project_id)
|
|
rootFolder: [_id:ObjectId()]
|
|
@doc = _id: doc_id, name: "old.tex", rev: 1
|
|
@folder = _id: folder_id
|
|
|
|
@ProjectGetter.getProjectWithoutLock = sinon.stub().yields(null, @project)
|
|
|
|
@ProjectEntityHandler.getAllEntitiesFromProject = sinon.stub()
|
|
@ProjectEntityHandler.getAllEntitiesFromProject
|
|
.onFirstCall()
|
|
.yields( null, @oldDocs = ['old-doc'], @oldFiles = ['old-file'])
|
|
@ProjectEntityHandler.getAllEntitiesFromProject
|
|
.onSecondCall()
|
|
.yields( null, @newDocs = ['new-doc'], @newFiles = ['new-file'])
|
|
|
|
@ProjectLocator.findElement = sinon.stub().yields(null, @doc, @path, @folder)
|
|
@subject._checkValidElementName = sinon.stub().yields()
|
|
@ProjectModel.findOneAndUpdate = sinon.stub().callsArgWith(3, null, @project)
|
|
|
|
@subject.renameEntity project_id, doc_id, 'doc', @newName, @callback
|
|
|
|
it 'should get the project', ->
|
|
@ProjectGetter.getProjectWithoutLock
|
|
.calledWith(project_id, {rootFolder:true, name:true})
|
|
.should.equal true
|
|
|
|
it 'should find the doc', ->
|
|
@ProjectLocator.findElement
|
|
.calledWith({element_id: doc_id, type: 'doc', project: @project })
|
|
.should.equal true
|
|
|
|
it 'should check the new name is valid', ->
|
|
@subject._checkValidElementName
|
|
.calledWith(@folder, @newName)
|
|
.should.equal true
|
|
|
|
it 'should update the doc name', ->
|
|
@ProjectModel.findOneAndUpdate
|
|
.calledWith(
|
|
{ _id: project_id },
|
|
{ $set: { "mongo.path.name": @newName } },
|
|
{ new: true }
|
|
).should.equal true
|
|
|
|
it 'calls the callback', ->
|
|
changes = { @oldDocs, @newDocs, @oldFiles, @newFiles }
|
|
@callback.calledWith(
|
|
null, @project.name, '/old.tex', '/new.tex', @doc.rev, changes
|
|
).should.equal true
|
|
|
|
describe 'addFolder', ->
|
|
beforeEach ->
|
|
@folderName = "folder1234"
|
|
@ProjectGetter.getProjectWithOnlyFolders = sinon.stub().callsArgWith(1, null, @project)
|
|
@subject._confirmFolder = sinon.stub().yields(folder_id)
|
|
@subject._putElement = sinon.stub().yields()
|
|
|
|
@subject.addFolder project_id, folder_id, @folderName, @callback
|
|
|
|
it 'gets the project', ->
|
|
@ProjectGetter.getProjectWithoutLock
|
|
.calledWith(project_id, {rootFolder:true, name: true})
|
|
.should.equal true
|
|
|
|
it 'checks the parent folder exists', ->
|
|
@subject._confirmFolder
|
|
.calledWith(@project, folder_id)
|
|
.should.equal true
|
|
|
|
it 'puts the element in mongo', ->
|
|
folderMatcher = sinon.match (folder) =>
|
|
folder.name == @folderName
|
|
|
|
@subject._putElement
|
|
.calledWithMatch(@project, folder_id, folderMatcher, 'folder')
|
|
.should.equal true
|
|
|
|
it 'calls the callback', ->
|
|
folderMatcher = sinon.match (folder) =>
|
|
folder.name == @folderName
|
|
|
|
@callback.calledWithMatch(null, folderMatcher, folder_id).should.equal true
|
|
|
|
describe '_removeElementFromMongoArray ', ->
|
|
beforeEach ->
|
|
@mongoPath = "folders[0].folders[5]"
|
|
@id = "12344"
|
|
@ProjectModel.update = sinon.stub().yields()
|
|
@ProjectModel.findOneAndUpdate = sinon.stub().yields(null, @project)
|
|
@subject._removeElementFromMongoArray @ProjectModel, @id, @mongoPath, @callback
|
|
|
|
it 'should unset', ->
|
|
update = { '$unset': { } }
|
|
update['$unset'][@mongoPath] = 1
|
|
@ProjectModel.update
|
|
.calledWith({ _id: @id }, update, {})
|
|
.should.equal true
|
|
|
|
it 'should pull', ->
|
|
@ProjectModel.findOneAndUpdate
|
|
.calledWith({ _id: @id }, { '$pull': { 'folders[0]': null } }, {'new': true})
|
|
.should.equal true
|
|
|
|
it 'should call the callback', ->
|
|
@callback.calledWith(null, @project).should.equal true
|
|
|
|
describe "_countElements", ->
|
|
beforeEach ->
|
|
@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", ->
|
|
expect(@subject._countElements @project).to.equal(26)
|
|
|
|
it "should deal with null folders", ->
|
|
@project.rootFolder[0].folders[0].folders = undefined
|
|
expect(@subject._countElements @project).to.equal(17)
|
|
|
|
it "should deal with null docs", ->
|
|
@project.rootFolder[0].folders[0].docs = undefined
|
|
expect(@subject._countElements @project).to.equal(23)
|
|
|
|
it "should deal with null fileRefs", ->
|
|
@project.rootFolder[0].folders[0].folders[0].fileRefs = undefined
|
|
expect(@subject._countElements @project).to.equal(23)
|
|
|
|
describe "_putElement", ->
|
|
beforeEach ->
|
|
@project =
|
|
_id: project_id
|
|
rootFolder: [_id:ObjectId()]
|
|
@folder =
|
|
_id: ObjectId()
|
|
name: "someFolder"
|
|
docs: [ {name: "another-doc.tex"} ]
|
|
fileRefs: [ {name: "another-file.tex"} ]
|
|
folders: [ {name: "another-folder"} ]
|
|
@doc =
|
|
_id: ObjectId()
|
|
name: "new.tex"
|
|
@path = mongo: "mongo.path", fileSystem: "/file/system/old.tex"
|
|
@ProjectLocator.findElement = sinon.stub().yields(null, @folder, @path)
|
|
@ProjectModel.findOneAndUpdate = sinon.stub().yields(null, @project)
|
|
|
|
describe "updating the project", ->
|
|
it "should use the correct mongo path", (done)->
|
|
@subject._putElement @project, @folder._id, @doc, "docs", (err)=>
|
|
@ProjectModel.findOneAndUpdate.args[0][0]._id.should.equal @project._id
|
|
assert.deepEqual @ProjectModel.findOneAndUpdate.args[0][1].$push[@path.mongo+".docs"], @doc
|
|
done()
|
|
|
|
it "should return the project in the callback", (done)->
|
|
@subject._putElement @project, @folder._id, @doc, "docs", (err, path, project)=>
|
|
assert.equal project, @project
|
|
done()
|
|
|
|
it "should add an s onto the type if not included", (done)->
|
|
@subject._putElement @project, @folder._id, @doc, "doc", (err)=>
|
|
assert.deepEqual @ProjectModel.findOneAndUpdate.args[0][1].$push[@path.mongo+".docs"], @doc
|
|
done()
|
|
|
|
it "should not call update if element is null", (done)->
|
|
@subject._putElement @project, @folder._id, null, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
done()
|
|
|
|
it "should default to root folder insert", (done)->
|
|
@subject._putElement @project, null, @doc, "doc", (err)=>
|
|
@ProjectLocator.findElement.args[0][0].element_id.should.equal @project.rootFolder[0]._id
|
|
done()
|
|
|
|
it "should error if the element has no _id", (done)->
|
|
doc =
|
|
name:"something"
|
|
@subject._putElement @project, @folder._id, doc, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
done()
|
|
|
|
it "should error if element name contains invalid characters", (done)->
|
|
doc =
|
|
_id: ObjectId()
|
|
name: "something*bad"
|
|
@subject._putElement @project, @folder._id, doc, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
err.should.deep.equal new Errors.InvalidNameError("invalid element name")
|
|
done()
|
|
|
|
it "should error if element name is too long", (done)->
|
|
doc =
|
|
_id: ObjectId()
|
|
name: new Array(200).join("long-") + "something"
|
|
@subject._putElement @project, @folder._id, doc, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
err.should.deep.equal new Errors.InvalidNameError("invalid element name")
|
|
done()
|
|
|
|
it "should error if the folder name is too long", (done)->
|
|
@path =
|
|
mongo: "mongo.path",
|
|
fileSystem: new Array(200).join("subdir/") + "foo"
|
|
@ProjectLocator.findElement.callsArgWith(1, null, @folder, @path)
|
|
doc =
|
|
_id: ObjectId()
|
|
name: "something"
|
|
@subject._putElement @project, @folder._id, doc, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
err.should.deep.equal new Errors.InvalidNameError("path too long")
|
|
done()
|
|
|
|
it "should error if a document already exists with the same name", (done)->
|
|
doc =
|
|
_id: ObjectId()
|
|
name: "another-doc.tex"
|
|
@subject._putElement @project, @folder, doc, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
err.should.deep.equal new Errors.InvalidNameError("file already exists")
|
|
done()
|
|
|
|
it "should error if a file already exists with the same name", (done)->
|
|
doc =
|
|
_id: ObjectId()
|
|
name: "another-file.tex"
|
|
@subject._putElement @project, @folder, doc, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
err.should.deep.equal new Errors.InvalidNameError("file already exists")
|
|
done()
|
|
|
|
it "should error if a folder already exists with the same name", (done)->
|
|
doc =
|
|
_id: ObjectId()
|
|
name: "another-folder"
|
|
@subject._putElement @project, @folder, doc, "doc", (err)=>
|
|
@ProjectModel.findOneAndUpdate.called.should.equal false
|
|
err.should.deep.equal new Errors.InvalidNameError("file already exists")
|
|
done()
|
|
|
|
describe '_checkValidElementName', ->
|
|
beforeEach ->
|
|
@folder =
|
|
docs: [ name: 'doc_name' ]
|
|
fileRefs: [ name: 'file_name' ]
|
|
folders: [ name: 'folder_name' ]
|
|
|
|
it 'returns an error if name matches any doc name', ->
|
|
@subject._checkValidElementName @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', ->
|
|
@subject._checkValidElementName @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', ->
|
|
@subject._checkValidElementName @folder, 'folder_name', (err) ->
|
|
expect(err).to.deep.equal new Errors.InvalidNameError("file already exists")
|
|
|
|
it 'returns nothing if name is valid', ->
|
|
@subject._checkValidElementName @folder, 'unique_name', (err) ->
|
|
expect(err).to.be.undefined
|
|
|
|
describe '_checkValidMove', ->
|
|
beforeEach ->
|
|
@destFolder = _id: folder_id
|
|
@destFolderPath = fileSystem: '/foo/bar'
|
|
@ProjectLocator.findElement = sinon.stub().yields(null, @destFolder, @destFolderPath)
|
|
@subject._checkValidElementName = sinon.stub().yields()
|
|
|
|
it 'checks the element name is valid', ->
|
|
@doc = _id: doc_id, name: 'doc_name'
|
|
@subject._checkValidMove @project, 'doc', @doc, fileSystem: '/main.tex', @destFolder._id, (err) =>
|
|
expect(err).to.be.undefined
|
|
@subject._checkValidElementName
|
|
.calledWith(@destFolder, @doc.name)
|
|
.should.equal true
|
|
|
|
it 'returns an error if trying to move a folder inside itself', ->
|
|
folder = name: 'folder_name'
|
|
@subject._checkValidMove @project, 'folder', folder, fileSystem: '/foo', @destFolder._id, (err) =>
|
|
expect(err).to.deep.equal new Errors.InvalidNameError("destination folder is a child folder of me")
|