2019-05-29 05:21:06 -04:00
|
|
|
/* eslint-disable
|
|
|
|
camelcase,
|
|
|
|
handle-callback-err,
|
|
|
|
max-len,
|
|
|
|
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 async = require('async')
|
|
|
|
const { expect } = require('chai')
|
|
|
|
const _ = require('underscore')
|
|
|
|
const mkdirp = require('mkdirp')
|
|
|
|
|
|
|
|
const Settings = require('settings-sharelatex')
|
|
|
|
const MockFileStoreApi = require('./helpers/MockFileStoreApi')
|
|
|
|
const request = require('./helpers/request')
|
|
|
|
const User = require('./helpers/User')
|
|
|
|
|
|
|
|
const MockClsiApi = require('./helpers/MockClsiApi')
|
|
|
|
|
|
|
|
const express = require('express')
|
|
|
|
const LinkedUrlProxy = express()
|
|
|
|
LinkedUrlProxy.get('/', (req, res, next) => {
|
|
|
|
if (req.query.url === 'http://example.com/foo') {
|
|
|
|
return res.send('foo foo foo')
|
|
|
|
} else if (req.query.url === 'http://example.com/bar') {
|
|
|
|
return res.send('bar bar bar')
|
|
|
|
} else {
|
|
|
|
return res.sendStatus(404)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('LinkedFiles', function() {
|
|
|
|
before(function(done) {
|
|
|
|
return LinkedUrlProxy.listen(6543, error => {
|
|
|
|
if (error != null) {
|
|
|
|
return done(error)
|
|
|
|
}
|
|
|
|
this.owner = new User()
|
|
|
|
return this.owner.login(() => mkdirp(Settings.path.dumpFolder, done))
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('creating a project linked file', function() {
|
|
|
|
before(function(done) {
|
|
|
|
this.source_doc_name = 'test.txt'
|
|
|
|
return async.series(
|
|
|
|
[
|
|
|
|
cb => {
|
|
|
|
return this.owner.createProject(
|
|
|
|
'plf-test-one',
|
|
|
|
{ template: 'blank' },
|
|
|
|
(error, project_id) => {
|
|
|
|
this.project_one_id = project_id
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
this.project_one = project
|
|
|
|
this.project_one_root_folder_id = project.rootFolder[0]._id.toString()
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.createProject(
|
|
|
|
'plf-test-two',
|
|
|
|
{ template: 'blank' },
|
|
|
|
(error, project_id) => {
|
|
|
|
this.project_two_id = project_id
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_two_id,
|
|
|
|
(error, project) => {
|
|
|
|
this.project_two = project
|
|
|
|
this.project_two_root_folder_id = project.rootFolder[0]._id.toString()
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.createDocInProject(
|
|
|
|
this.project_two_id,
|
|
|
|
this.project_two_root_folder_id,
|
|
|
|
this.source_doc_name,
|
|
|
|
(error, doc_id) => {
|
|
|
|
this.source_doc_id = doc_id
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.createDocInProject(
|
|
|
|
this.project_two_id,
|
|
|
|
this.project_two_root_folder_id,
|
|
|
|
'some-harmless-doc.txt',
|
|
|
|
(error, doc_id) => {
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
],
|
|
|
|
done
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should produce a list of the users projects', function(done) {
|
|
|
|
return this.owner.request.get(
|
|
|
|
{
|
|
|
|
url: '/user/projects',
|
|
|
|
json: true
|
|
|
|
},
|
|
|
|
(err, response, body) => {
|
|
|
|
expect(err).to.not.exist
|
|
|
|
expect(body).to.deep.equal({
|
|
|
|
projects: [
|
|
|
|
{
|
|
|
|
_id: this.project_one_id,
|
|
|
|
name: 'plf-test-one',
|
|
|
|
accessLevel: 'owner'
|
|
|
|
},
|
|
|
|
{
|
|
|
|
_id: this.project_two_id,
|
|
|
|
name: 'plf-test-two',
|
|
|
|
accessLevel: 'owner'
|
|
|
|
}
|
|
|
|
]
|
|
|
|
})
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should produce a list of entities in the project', function(done) {
|
|
|
|
return this.owner.request.get(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_two_id}/entities`,
|
|
|
|
json: true
|
|
|
|
},
|
|
|
|
(err, response, body) => {
|
|
|
|
expect(err).to.not.exist
|
|
|
|
expect(body).to.deep.equal({
|
|
|
|
project_id: this.project_two_id,
|
|
|
|
entities: [
|
|
|
|
{ path: '/main.tex', type: 'doc' },
|
|
|
|
{ path: '/some-harmless-doc.txt', type: 'doc' },
|
|
|
|
{ path: '/test.txt', type: 'doc' }
|
|
|
|
]
|
|
|
|
})
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should import a file from the source project', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_one_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
name: 'test-link.txt',
|
|
|
|
parent_folder_id: this.project_one_root_folder_id,
|
|
|
|
provider: 'project_file',
|
|
|
|
data: {
|
|
|
|
source_project_id: this.project_two_id,
|
|
|
|
source_entity_path: `/${this.source_doc_name}`
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
const { new_file_id } = body
|
|
|
|
this.existing_file_id = new_file_id
|
|
|
|
expect(new_file_id).to.exist
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
return done(error)
|
|
|
|
}
|
|
|
|
const firstFile = project.rootFolder[0].fileRefs[0]
|
|
|
|
expect(firstFile._id.toString()).to.equal(new_file_id.toString())
|
|
|
|
expect(firstFile.linkedFileData).to.deep.equal({
|
|
|
|
provider: 'project_file',
|
|
|
|
source_project_id: this.project_two_id,
|
|
|
|
source_entity_path: `/${this.source_doc_name}`
|
|
|
|
})
|
|
|
|
expect(firstFile.name).to.equal('test-link.txt')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should refresh the file', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_one_id}/linked_file/${
|
|
|
|
this.existing_file_id
|
|
|
|
}/refresh`,
|
|
|
|
json: true
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
const { new_file_id } = body
|
|
|
|
expect(new_file_id).to.exist
|
|
|
|
expect(new_file_id).to.not.equal(this.existing_file_id)
|
|
|
|
this.refreshed_file_id = new_file_id
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
return done(error)
|
|
|
|
}
|
|
|
|
const firstFile = project.rootFolder[0].fileRefs[0]
|
|
|
|
expect(firstFile._id.toString()).to.equal(new_file_id.toString())
|
|
|
|
expect(firstFile.name).to.equal('test-link.txt')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
2019-06-21 09:46:09 -04:00
|
|
|
it('should not allow to create a linked-file with v1 id', function(done) {
|
2019-05-29 05:21:06 -04:00
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_one_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
name: 'test-link-should-not-work.txt',
|
|
|
|
parent_folder_id: this.project_one_root_folder_id,
|
|
|
|
provider: 'project_file',
|
|
|
|
data: {
|
|
|
|
v1_source_doc_id: 1234,
|
|
|
|
source_entity_path: `/${this.source_doc_name}`
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
expect(response.statusCode).to.equal(403)
|
|
|
|
expect(body).to.equal('You do not have access to this project')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('with a linked project_file from a v1 project that has not been imported', function() {
|
|
|
|
before(function(done) {
|
|
|
|
return async.series(
|
|
|
|
[
|
|
|
|
cb => {
|
|
|
|
return this.owner.createProject(
|
|
|
|
'plf-v1-test-one',
|
|
|
|
{ template: 'blank' },
|
|
|
|
(error, project_id) => {
|
|
|
|
this.project_one_id = project_id
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
this.project_one = project
|
|
|
|
this.project_one_root_folder_id = project.rootFolder[0]._id.toString()
|
|
|
|
this.project_one.rootFolder[0].fileRefs.push({
|
|
|
|
linkedFileData: {
|
|
|
|
provider: 'project_file',
|
|
|
|
v1_source_doc_id: 9999999, // We won't find this id in the database
|
|
|
|
source_entity_path: 'example.jpeg'
|
|
|
|
},
|
|
|
|
_id: 'abcd',
|
|
|
|
rev: 0,
|
|
|
|
created: new Date(),
|
|
|
|
name: 'example.jpeg'
|
|
|
|
})
|
|
|
|
return this.owner.saveProject(this.project_one, cb)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
],
|
|
|
|
done
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
2019-06-21 09:46:09 -04:00
|
|
|
it('should refuse to refresh', function(done) {
|
2019-05-29 05:21:06 -04:00
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_one_id}/linked_file/abcd/refresh`,
|
|
|
|
json: true
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
expect(response.statusCode).to.equal(409)
|
|
|
|
expect(body).to.equal(
|
|
|
|
'Sorry, the source project is not yet imported to Overleaf v2. Please import it to Overleaf v2 to refresh this file'
|
|
|
|
)
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('creating a URL based linked file', function() {
|
|
|
|
before(function(done) {
|
|
|
|
return this.owner.createProject(
|
|
|
|
'url-linked-files-project',
|
|
|
|
{ template: 'blank' },
|
|
|
|
(error, project_id) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
this.project_id = project_id
|
|
|
|
return this.owner.getProject(project_id, (error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
this.project = project
|
|
|
|
this.root_folder_id = project.rootFolder[0]._id.toString()
|
|
|
|
return done()
|
|
|
|
})
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should download the URL and create a file with the contents and linkedFileData', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
provider: 'url',
|
|
|
|
data: {
|
|
|
|
url: 'http://example.com/foo'
|
|
|
|
},
|
|
|
|
parent_folder_id: this.root_folder_id,
|
|
|
|
name: 'url-test-file-1'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
return this.owner.getProject(this.project_id, (error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
const file = project.rootFolder[0].fileRefs[0]
|
|
|
|
expect(file.linkedFileData).to.deep.equal({
|
|
|
|
provider: 'url',
|
|
|
|
url: 'http://example.com/foo'
|
|
|
|
})
|
|
|
|
return this.owner.request.get(
|
|
|
|
`/project/${this.project_id}/file/${file._id}`,
|
2019-08-07 10:04:04 -04:00
|
|
|
(error, response, body) => {
|
2019-05-29 05:21:06 -04:00
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
expect(body).to.equal('foo foo foo')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should replace and update a URL based linked file', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
provider: 'url',
|
|
|
|
data: {
|
|
|
|
url: 'http://example.com/foo'
|
|
|
|
},
|
|
|
|
parent_folder_id: this.root_folder_id,
|
|
|
|
name: 'url-test-file-2'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
provider: 'url',
|
|
|
|
data: {
|
|
|
|
url: 'http://example.com/bar'
|
|
|
|
},
|
|
|
|
parent_folder_id: this.root_folder_id,
|
|
|
|
name: 'url-test-file-2'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_id,
|
|
|
|
(error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
const file = project.rootFolder[0].fileRefs[1]
|
|
|
|
expect(file.linkedFileData).to.deep.equal({
|
|
|
|
provider: 'url',
|
|
|
|
url: 'http://example.com/bar'
|
|
|
|
})
|
|
|
|
return this.owner.request.get(
|
|
|
|
`/project/${this.project_id}/file/${file._id}`,
|
2019-08-07 10:04:04 -04:00
|
|
|
(error, response, body) => {
|
2019-05-29 05:21:06 -04:00
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
expect(body).to.equal('bar bar bar')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should return an error if the URL does not succeed', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
provider: 'url',
|
|
|
|
data: {
|
|
|
|
url: 'http://example.com/does-not-exist'
|
|
|
|
},
|
|
|
|
parent_folder_id: this.root_folder_id,
|
|
|
|
name: 'url-test-file-3'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(422) // unprocessable
|
|
|
|
expect(body).to.equal(
|
|
|
|
'Your URL could not be reached (404 status code). Please check it and try again.'
|
|
|
|
)
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should return an error if the URL is invalid', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
provider: 'url',
|
|
|
|
data: {
|
|
|
|
url: '!^$%'
|
|
|
|
},
|
|
|
|
parent_folder_id: this.root_folder_id,
|
|
|
|
name: 'url-test-file-4'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(422) // unprocessable
|
|
|
|
expect(body).to.equal(
|
|
|
|
'Your URL is not valid. Please check it and try again.'
|
|
|
|
)
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should return an error if the URL uses a non-http protocol', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
provider: 'url',
|
|
|
|
data: {
|
|
|
|
url: 'ftp://localhost'
|
|
|
|
},
|
|
|
|
parent_folder_id: this.root_folder_id,
|
|
|
|
name: 'url-test-file-5'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(422) // unprocessable
|
|
|
|
expect(body).to.equal(
|
|
|
|
'Your URL is not valid. Please check it and try again.'
|
|
|
|
)
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
2019-06-21 09:46:09 -04:00
|
|
|
it('should accept a URL withuot a leading http://, and add it', function(done) {
|
2019-05-29 05:21:06 -04:00
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
provider: 'url',
|
|
|
|
data: {
|
|
|
|
url: 'example.com/foo'
|
|
|
|
},
|
|
|
|
parent_folder_id: this.root_folder_id,
|
|
|
|
name: 'url-test-file-6'
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
return this.owner.getProject(this.project_id, (error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
const file = _.find(
|
|
|
|
project.rootFolder[0].fileRefs,
|
|
|
|
file => file.name === 'url-test-file-6'
|
|
|
|
)
|
|
|
|
expect(file.linkedFileData).to.deep.equal({
|
|
|
|
provider: 'url',
|
|
|
|
url: 'http://example.com/foo'
|
|
|
|
})
|
|
|
|
return this.owner.request.get(
|
|
|
|
`/project/${this.project_id}/file/${file._id}`,
|
2019-08-07 10:04:04 -04:00
|
|
|
(error, response, body) => {
|
2019-05-29 05:21:06 -04:00
|
|
|
if (error != null) {
|
|
|
|
throw error
|
|
|
|
}
|
|
|
|
expect(response.statusCode).to.equal(200)
|
|
|
|
expect(body).to.equal('foo foo foo')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
// TODO: Add test for asking for host that return ENOTFOUND
|
|
|
|
// (This will probably end up handled by the proxy)
|
|
|
|
|
|
|
|
describe('creating a linked output file', function() {
|
|
|
|
before(function(done) {
|
|
|
|
return async.series(
|
|
|
|
[
|
|
|
|
cb => {
|
|
|
|
return this.owner.createProject(
|
|
|
|
'output-test-one',
|
|
|
|
{ template: 'blank' },
|
|
|
|
(error, project_id) => {
|
|
|
|
this.project_one_id = project_id
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
this.project_one = project
|
|
|
|
this.project_one_root_folder_id = project.rootFolder[0]._id.toString()
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.createProject(
|
|
|
|
'output-test-two',
|
|
|
|
{ template: 'blank' },
|
|
|
|
(error, project_id) => {
|
|
|
|
this.project_two_id = project_id
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_two_id,
|
|
|
|
(error, project) => {
|
|
|
|
this.project_two = project
|
|
|
|
this.project_two_root_folder_id = project.rootFolder[0]._id.toString()
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
],
|
|
|
|
done
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should import the project.pdf file from the source project', function(done) {
|
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_one_id}/linked_file`,
|
|
|
|
json: {
|
|
|
|
name: 'test.pdf',
|
|
|
|
parent_folder_id: this.project_one_root_folder_id,
|
|
|
|
provider: 'project_output_file',
|
|
|
|
data: {
|
|
|
|
source_project_id: this.project_two_id,
|
|
|
|
source_output_file_path: 'project.pdf',
|
|
|
|
build_id: '1234-abcd'
|
|
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
const { new_file_id } = body
|
|
|
|
this.existing_file_id = new_file_id
|
|
|
|
expect(new_file_id).to.exist
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
return done(error)
|
|
|
|
}
|
|
|
|
const firstFile = project.rootFolder[0].fileRefs[0]
|
|
|
|
expect(firstFile._id.toString()).to.equal(new_file_id.toString())
|
|
|
|
expect(firstFile.linkedFileData).to.deep.equal({
|
|
|
|
provider: 'project_output_file',
|
|
|
|
source_project_id: this.project_two_id,
|
|
|
|
source_output_file_path: 'project.pdf',
|
|
|
|
build_id: '1234-abcd'
|
|
|
|
})
|
|
|
|
expect(firstFile.name).to.equal('test.pdf')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
2019-06-21 09:46:09 -04:00
|
|
|
it('should refresh the file', function(done) {
|
2019-05-29 05:21:06 -04:00
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_one_id}/linked_file/${
|
|
|
|
this.existing_file_id
|
|
|
|
}/refresh`,
|
|
|
|
json: true
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
const { new_file_id } = body
|
|
|
|
expect(new_file_id).to.exist
|
|
|
|
expect(new_file_id).to.not.equal(this.existing_file_id)
|
|
|
|
this.refreshed_file_id = new_file_id
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
if (error != null) {
|
|
|
|
return done(error)
|
|
|
|
}
|
|
|
|
const firstFile = project.rootFolder[0].fileRefs[0]
|
|
|
|
expect(firstFile._id.toString()).to.equal(new_file_id.toString())
|
|
|
|
expect(firstFile.name).to.equal('test.pdf')
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2019-06-21 09:46:09 -04:00
|
|
|
describe('with a linked project_output_file from a v1 project that has not been imported', function() {
|
2019-05-29 05:21:06 -04:00
|
|
|
before(function(done) {
|
|
|
|
return async.series(
|
|
|
|
[
|
|
|
|
cb => {
|
|
|
|
return this.owner.createProject(
|
|
|
|
'output-v1-test-one',
|
|
|
|
{ template: 'blank' },
|
|
|
|
(error, project_id) => {
|
|
|
|
this.project_one_id = project_id
|
|
|
|
return cb(error)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
},
|
|
|
|
cb => {
|
|
|
|
return this.owner.getProject(
|
|
|
|
this.project_one_id,
|
|
|
|
(error, project) => {
|
|
|
|
this.project_one = project
|
|
|
|
this.project_one_root_folder_id = project.rootFolder[0]._id.toString()
|
|
|
|
this.project_one.rootFolder[0].fileRefs.push({
|
|
|
|
linkedFileData: {
|
|
|
|
provider: 'project_output_file',
|
|
|
|
v1_source_doc_id: 9999999, // We won't find this id in the database
|
|
|
|
source_output_file_path: 'project.pdf'
|
|
|
|
},
|
|
|
|
_id: 'abcdef',
|
|
|
|
rev: 0,
|
|
|
|
created: new Date(),
|
|
|
|
name: 'whatever.pdf'
|
|
|
|
})
|
|
|
|
return this.owner.saveProject(this.project_one, cb)
|
|
|
|
}
|
|
|
|
)
|
|
|
|
}
|
|
|
|
],
|
|
|
|
done
|
|
|
|
)
|
|
|
|
})
|
|
|
|
|
2019-06-21 09:46:09 -04:00
|
|
|
it('should refuse to refresh', function(done) {
|
2019-05-29 05:21:06 -04:00
|
|
|
return this.owner.request.post(
|
|
|
|
{
|
|
|
|
url: `/project/${this.project_one_id}/linked_file/abcdef/refresh`,
|
|
|
|
json: true
|
|
|
|
},
|
|
|
|
(error, response, body) => {
|
|
|
|
expect(response.statusCode).to.equal(409)
|
|
|
|
expect(body).to.equal(
|
|
|
|
'Sorry, the source project is not yet imported to Overleaf v2. Please import it to Overleaf v2 to refresh this file'
|
|
|
|
)
|
|
|
|
return done()
|
|
|
|
}
|
|
|
|
)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|