github/overleaf
1
0
Fork 0
mirror of https://github.com/overleaf/overleaf.git synced 2024-11-21 20:47:08 -05:00
Code Issues Projects Releases Packages Wiki Activity

Prettier: convert test/acceptance decaffeinated files to Prettier format

Browse source
This commit is contained in:
Simon Detheridge 2019-12-16 10:42:41 +00:00
parent b8e7abd25e
commit e4b1106761
2 changed files with 364 additions and 322 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

138
services/filestore/test/acceptance/js/FilestoreApp.js
View file

@ -13,67 +13,97 @@
* DS207: Consider shorter variations of null checks
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
*/
const app = require('../../../app');
require("logger-sharelatex").logger.level("info");
const logger = require("logger-sharelatex");
const Settings = require("settings-sharelatex");
const request = require('request');
const app = require('../../../app')
require('logger-sharelatex').logger.level('info')
const logger = require('logger-sharelatex')
const Settings = require('settings-sharelatex')
const request = require('request')
const S3_TRIES = 30;
const S3_TRIES = 30
module.exports = {
running: false,
initing: false,
callbacks: [],
ensureRunning(callback) {
if (callback == null) { callback = function(error) {}; }
if (this.running) {
return callback();
} else if (this.initing) {
return this.callbacks.push(callback);
} else {
this.initing = true;
this.callbacks.push(callback);
return app.listen(__guard__(Settings.internal != null ? Settings.internal.filestore : undefined, x => x.port), "localhost", error => {
if (error != null) { throw error; }
this.running = true;
logger.log("filestore running in dev mode");
running: false,
initing: false,
callbacks: [],
ensureRunning(callback) {
if (callback == null) {
callback = function(error) {}
}
if (this.running) {
return callback()
} else if (this.initing) {
return this.callbacks.push(callback)
} else {
this.initing = true
this.callbacks.push(callback)
return app.listen(
__guard__(
Settings.internal != null ? Settings.internal.filestore : undefined,
x => x.port
),
'localhost',
error => {
if (error != null) {
throw error
}
this.running = true
logger.log('filestore running in dev mode')
return (() => {
const result = [];
for (callback of Array.from(this.callbacks)) {
result.push(callback());
}
return result;
})();
});
}
},
return (() => {
const result = []
for (callback of Array.from(this.callbacks)) {
result.push(callback())
}
return result
})()
}
)
}
},
waitForS3(callback, tries) {
if (!(Settings.filestore.s3 != null ? Settings.filestore.s3.endpoint : undefined)) { return callback(); }
if (!tries) { tries = 1; }
waitForS3(callback, tries) {
if (
!(Settings.filestore.s3 != null
? Settings.filestore.s3.endpoint
: undefined)
) {
return callback()
}
if (!tries) {
tries = 1
}
return request.get(`${Settings.filestore.s3.endpoint}/`, (err, response) => {
console.log(err, response != null ? response.statusCode : undefined, tries);
if (!err && [200, 404].includes(response != null ? response.statusCode : undefined)) {
return callback();
}
return request.get(
`${Settings.filestore.s3.endpoint}/`,
(err, response) => {
console.log(
err,
response != null ? response.statusCode : undefined,
tries
)
if (
!err &&
[200, 404].includes(
response != null ? response.statusCode : undefined
)
) {
return callback()
}
if (tries === S3_TRIES) {
return callback('timed out waiting for S3');
}
if (tries === S3_TRIES) {
return callback('timed out waiting for S3')
}
return setTimeout(
() => {
return this.waitForS3(callback, tries + 1);
},
1000
);
});
}
};
return setTimeout(() => {
return this.waitForS3(callback, tries + 1)
}, 1000)
}
)
}
}
function __guard__(value, transform) {
return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
}
return typeof value !== 'undefined' && value !== null
? transform(value)
: undefined
}

548
services/filestore/test/acceptance/js/SendingFileTest.js
View file

@ -12,303 +12,315 @@
* DS103: Rewrite code to no longer use __guard__
* 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.should();
const {
expect
} = chai;
const modulePath = "../../../app/js/LocalFileWriter.js";
const SandboxedModule = require('sandboxed-module');
const fs = require("fs");
const request = require("request");
const settings = require("settings-sharelatex");
const FilestoreApp = require("./FilestoreApp");
const async = require('async');
const { assert } = require('chai')
const sinon = require('sinon')
const chai = require('chai')
const should = chai.should()
const { expect } = chai
const modulePath = '../../../app/js/LocalFileWriter.js'
const SandboxedModule = require('sandboxed-module')
const fs = require('fs')
const request = require('request')
const settings = require('settings-sharelatex')
const FilestoreApp = require('./FilestoreApp')
const async = require('async')
const getMetric = (filestoreUrl, metric, cb) =>
request.get(`${filestoreUrl}/metrics`, function(err, res) {
expect(res.statusCode).to.equal(200)
const metricRegex = new RegExp(`^${metric}{[^}]+} ([0-9]+)$`, 'm')
return cb(parseInt(__guard__(metricRegex.exec(res.body), x => x[1]) || '0'))
})
const getMetric = (filestoreUrl, metric, cb) => request.get(`${filestoreUrl}/metrics`, function(err, res) {
expect(res.statusCode).to.equal(200);
const metricRegex = new RegExp(`^${metric}{[^}]+} ([0-9]+)$`, "m");
return cb(parseInt(__guard__(metricRegex.exec(res.body), x => x[1]) || '0'));
});
describe('Filestore', function() {
before(function(done) {
this.localFileReadPath = '/tmp/filestore_acceptence_tests_file_read.txt'
this.localFileWritePath = '/tmp/filestore_acceptence_tests_file_write.txt'
describe("Filestore", function() {
before(function(done){
this.localFileReadPath = "/tmp/filestore_acceptence_tests_file_read.txt";
this.localFileWritePath = "/tmp/filestore_acceptence_tests_file_write.txt";
this.constantFileContent = [
'hello world',
`line 2 goes here ${Math.random()}`,
'there are 3 lines in all'
].join('\n')
this.constantFileContent = [
"hello world",
`line 2 goes here ${Math.random()}`,
"there are 3 lines in all"
].join("\n");
this.filestoreUrl = `http://localhost:${settings.internal.filestore.port}`
return fs.writeFile(
this.localFileReadPath,
this.constantFileContent,
function(err) {
if (err) {
return done(err)
}
return FilestoreApp.waitForS3(done)
}
)
})
this.filestoreUrl = `http://localhost:${settings.internal.filestore.port}`;
return fs.writeFile(this.localFileReadPath, this.constantFileContent, function(err) {
if (err) { return done(err); }
return FilestoreApp.waitForS3(done);
});
});
beforeEach(function(done) {
return FilestoreApp.ensureRunning(() => {
return async.parallel(
[
cb => {
return fs.unlink(this.localFileWritePath, () => cb())
},
cb => {
return getMetric(this.filestoreUrl, 's3_egress', metric => {
this.previousEgress = metric
return cb()
})
},
cb => {
return getMetric(this.filestoreUrl, 's3_ingress', metric => {
this.previousIngress = metric
return cb()
})
}
],
done
)
})
})
beforeEach(function(done){
return FilestoreApp.ensureRunning(() => {
return async.parallel([
cb => {
return fs.unlink(this.localFileWritePath, () => cb());
},
cb => {
return getMetric(this.filestoreUrl, 's3_egress', metric => {
this.previousEgress = metric;
return cb();
});
},
cb => {
return getMetric(this.filestoreUrl, 's3_ingress', metric => {
this.previousIngress = metric;
return cb();
});
}
], done);
});
});
it('should send a 200 for status endpoint', function(done) {
return request(`${this.filestoreUrl}/status`, function(
err,
response,
body
) {
response.statusCode.should.equal(200)
body.indexOf('filestore').should.not.equal(-1)
body.indexOf('up').should.not.equal(-1)
return done()
})
})
it("should send a 200 for status endpoint", function(done){
return request(`${this.filestoreUrl}/status`, function(err, response, body){
response.statusCode.should.equal(200);
body.indexOf("filestore").should.not.equal(-1);
body.indexOf("up").should.not.equal(-1);
return done();
});
});
describe('with a file on the server', function() {
beforeEach(function(done) {
this.timeout(1000 * 10)
this.file_id = Math.random()
this.fileUrl = `${this.filestoreUrl}/project/acceptence_tests/file/${this.file_id}`
describe("with a file on the server", function() {
const writeStream = request.post(this.fileUrl)
beforeEach(function(done){
this.timeout(1000 * 10);
this.file_id = Math.random();
this.fileUrl = `${this.filestoreUrl}/project/acceptence_tests/file/${this.file_id}`;
writeStream.on('end', done)
return fs.createReadStream(this.localFileReadPath).pipe(writeStream)
})
const writeStream = request.post(this.fileUrl);
it('should return 404 for a non-existant id', function(done) {
this.timeout(1000 * 20)
const options = { uri: this.fileUrl + '___this_is_clearly_wrong___' }
return request.get(options, (err, response, body) => {
response.statusCode.should.equal(404)
return done()
})
})
writeStream.on("end", done);
return fs.createReadStream(this.localFileReadPath).pipe(writeStream);
});
it('should record an egress metric for the upload', function(done) {
return getMetric(this.filestoreUrl, 's3_egress', metric => {
expect(metric - this.previousEgress).to.equal(
this.constantFileContent.length
)
return done()
})
})
it("should return 404 for a non-existant id", function(done) {
this.timeout(1000 * 20);
const options =
{uri: this.fileUrl + '___this_is_clearly_wrong___'};
return request.get(options, (err, response, body) => {
response.statusCode.should.equal(404);
return done();
});
});
it('should return the file size on a HEAD request', function(done) {
const expectedLength = Buffer.byteLength(this.constantFileContent)
return request.head(this.fileUrl, (err, res) => {
expect(res.statusCode).to.equal(200)
expect(res.headers['content-length']).to.equal(
expectedLength.toString()
)
return done()
})
})
it('should record an egress metric for the upload', function(done) {
return getMetric(this.filestoreUrl, 's3_egress', metric => {
expect(metric - this.previousEgress).to.equal(this.constantFileContent.length);
return done();
});
});
it('should be able get the file back', function(done) {
this.timeout(1000 * 10)
return request.get(this.fileUrl, (err, response, body) => {
body.should.equal(this.constantFileContent)
return done()
})
})
it("should return the file size on a HEAD request", function(done) {
const expectedLength = Buffer.byteLength(this.constantFileContent);
return request.head(this.fileUrl, (err, res) => {
expect(res.statusCode).to.equal(200);
expect(res.headers['content-length']).to.equal(expectedLength.toString());
return done();
});
});
it('should record an ingress metric when downloading the file', function(done) {
this.timeout(1000 * 10)
return request.get(this.fileUrl, () => {
return getMetric(this.filestoreUrl, 's3_ingress', metric => {
expect(metric - this.previousIngress).to.equal(
this.constantFileContent.length
)
return done()
})
})
})
it("should be able get the file back", function(done){
this.timeout(1000 * 10);
return request.get(this.fileUrl, (err, response, body)=> {
body.should.equal(this.constantFileContent);
return done();
});
});
it('should be able to get back the first 9 bytes of the file', function(done) {
this.timeout(1000 * 10)
const options = {
uri: this.fileUrl,
headers: {
Range: 'bytes=0-8'
}
}
return request.get(options, (err, response, body) => {
body.should.equal('hello wor')
return done()
})
})
it("should record an ingress metric when downloading the file", function(done){
this.timeout(1000 * 10);
return request.get(this.fileUrl, () => {
return getMetric(this.filestoreUrl, 's3_ingress', metric => {
expect(metric - this.previousIngress).to.equal(this.constantFileContent.length);
return done();
});
});
});
it('should record an ingress metric for a partial download', function(done) {
this.timeout(1000 * 10)
const options = {
uri: this.fileUrl,
headers: {
Range: 'bytes=0-8'
}
}
return request.get(options, () => {
return getMetric(this.filestoreUrl, 's3_ingress', metric => {
expect(metric - this.previousIngress).to.equal(9)
return done()
})
})
})
it("should be able to get back the first 9 bytes of the file", function(done) {
this.timeout(1000 * 10);
const options = {
uri: this.fileUrl,
headers: {
'Range': 'bytes=0-8'
}
};
return request.get(options, (err, response, body)=> {
body.should.equal('hello wor');
return done();
});
});
it('should be able to get back bytes 4 through 10 of the file', function(done) {
this.timeout(1000 * 10)
const options = {
uri: this.fileUrl,
headers: {
Range: 'bytes=4-10'
}
}
return request.get(options, (err, response, body) => {
body.should.equal('o world')
return done()
})
})
it("should record an ingress metric for a partial download", function(done){
this.timeout(1000 * 10);
const options = {
uri: this.fileUrl,
headers: {
'Range': 'bytes=0-8'
}
};
return request.get(options, ()=> {
return getMetric(this.filestoreUrl, 's3_ingress', metric => {
expect(metric - this.previousIngress).to.equal(9);
return done();
});
});
});
it('should be able to delete the file', function(done) {
this.timeout(1000 * 20)
return request.del(this.fileUrl, (err, response, body) => {
response.statusCode.should.equal(204)
return request.get(this.fileUrl, (err, response, body) => {
response.statusCode.should.equal(404)
return done()
})
})
})
it("should be able to get back bytes 4 through 10 of the file", function(done) {
this.timeout(1000 * 10);
const options = {
uri: this.fileUrl,
headers: {
'Range': 'bytes=4-10'
}
};
return request.get(options, (err, response, body)=> {
body.should.equal('o world');
return done();
});
});
return it('should be able to copy files', function(done) {
this.timeout(1000 * 20)
it("should be able to delete the file", function(done){
this.timeout(1000 * 20);
return request.del(this.fileUrl, (err, response, body)=> {
response.statusCode.should.equal(204);
return request.get(this.fileUrl, (err, response, body)=> {
response.statusCode.should.equal(404);
return done();
});
});
});
const newProjectID = 'acceptence_tests_copyied_project'
const newFileId = Math.random()
const newFileUrl = `${this.filestoreUrl}/project/${newProjectID}/file/${newFileId}`
const opts = {
method: 'put',
uri: newFileUrl,
json: {
source: {
project_id: 'acceptence_tests',
file_id: this.file_id
}
}
}
return request(opts, (err, response, body) => {
response.statusCode.should.equal(200)
return request.del(this.fileUrl, (err, response, body) => {
response.statusCode.should.equal(204)
return request.get(newFileUrl, (err, response, body) => {
body.should.equal(this.constantFileContent)
return done()
})
})
})
})
})
return it("should be able to copy files", function(done){
this.timeout(1000 * 20);
return describe('with a pdf file', function() {
beforeEach(function(done) {
this.timeout(1000 * 10)
this.file_id = Math.random()
this.fileUrl = `${this.filestoreUrl}/project/acceptence_tests/file/${this.file_id}`
this.localFileReadPath = __dirname + '/../../fixtures/test.pdf'
return fs.stat(this.localFileReadPath, (err, stat) => {
this.localFileSize = stat.size
const writeStream = request.post(this.fileUrl)
const newProjectID = "acceptence_tests_copyied_project";
const newFileId = Math.random();
const newFileUrl = `${this.filestoreUrl}/project/${newProjectID}/file/${newFileId}`;
const opts = {
method: 'put',
uri: newFileUrl,
json: {
source: {
project_id:"acceptence_tests",
file_id: this.file_id
}
}
};
return request(opts, (err, response, body)=> {
response.statusCode.should.equal(200);
return request.del(this.fileUrl, (err, response, body)=> {
response.statusCode.should.equal(204);
return request.get(newFileUrl, (err, response, body)=> {
body.should.equal(this.constantFileContent);
return done();
});
});
});
});
});
writeStream.on('end', done)
return fs.createReadStream(this.localFileReadPath).pipe(writeStream)
})
})
return describe("with a pdf file", function() {
it('should record an egress metric for the upload', function(done) {
return getMetric(this.filestoreUrl, 's3_egress', metric => {
expect(metric - this.previousEgress).to.equal(this.localFileSize)
return done()
})
})
beforeEach(function(done){
this.timeout(1000 * 10);
this.file_id = Math.random();
this.fileUrl = `${this.filestoreUrl}/project/acceptence_tests/file/${this.file_id}`;
this.localFileReadPath = __dirname + '/../../fixtures/test.pdf';
return fs.stat(this.localFileReadPath, (err, stat) => {
this.localFileSize = stat.size;
const writeStream = request.post(this.fileUrl);
it('should be able get the file back', function(done) {
this.timeout(1000 * 10)
return request.get(this.fileUrl, (err, response, body) => {
expect(body.substring(0, 8)).to.equal('%PDF-1.5')
return done()
})
})
writeStream.on("end", done);
return fs.createReadStream(this.localFileReadPath).pipe(writeStream);
});
});
describe('getting the preview image', function() {
beforeEach(function() {
return (this.previewFileUrl = `${this.fileUrl}?style=preview`)
})
it('should record an egress metric for the upload', function(done) {
return getMetric(this.filestoreUrl, 's3_egress', metric => {
expect(metric - this.previousEgress).to.equal(this.localFileSize);
return done();
});
});
it('should not time out', function(done) {
this.timeout(1000 * 20)
return request.get(this.previewFileUrl, (err, response, body) => {
expect(response).to.not.equal(null)
return done()
})
})
it("should be able get the file back", function(done){
this.timeout(1000 * 10);
return request.get(this.fileUrl, (err, response, body)=> {
expect(body.substring(0, 8)).to.equal('%PDF-1.5');
return done();
});
});
return it('should respond with image data', function(done) {
// note: this test relies of the imagemagick conversion working
this.timeout(1000 * 20)
return request.get(this.previewFileUrl, (err, response, body) => {
expect(response.statusCode).to.equal(200)
expect(body.length).to.be.greaterThan(400)
return done()
})
})
})
describe("getting the preview image", function() {
return describe('warming the cache', function() {
beforeEach(function() {
return (this.fileUrl = this.fileUrl + '?style=preview&cacheWarm=true')
})
beforeEach(function() {
return this.previewFileUrl = `${this.fileUrl}?style=preview`;
});
it('should not time out', function(done) {
this.timeout(1000 * 20)
return request.get(this.fileUrl, (err, response, body) => {
expect(response).to.not.equal(null)
return done()
})
})
it("should not time out", function(done) {
this.timeout(1000 * 20);
return request.get(this.previewFileUrl, (err, response, body) => {
expect(response).to.not.equal(null);
return done();
});
});
return it("should respond with image data", function(done) {
// note: this test relies of the imagemagick conversion working
this.timeout(1000 * 20);
return request.get(this.previewFileUrl, (err, response, body) => {
expect(response.statusCode).to.equal(200);
expect(body.length).to.be.greaterThan(400);
return done();
});
});
});
return describe("warming the cache", function() {
beforeEach(function() {
return this.fileUrl = this.fileUrl + '?style=preview&cacheWarm=true';
});
it("should not time out", function(done) {
this.timeout(1000 * 20);
return request.get(this.fileUrl, (err, response, body) => {
expect(response).to.not.equal(null);
return done();
});
});
return it("should respond with only an 'OK'", function(done) {
// note: this test relies of the imagemagick conversion working
this.timeout(1000 * 20);
return request.get(this.fileUrl, (err, response, body) => {
expect(response.statusCode).to.equal(200);
body.should.equal('OK');
return done();
});
});
});
});
});
return it("should respond with only an 'OK'", function(done) {
// note: this test relies of the imagemagick conversion working
this.timeout(1000 * 20)
return request.get(this.fileUrl, (err, response, body) => {
expect(response.statusCode).to.equal(200)
body.should.equal('OK')
return done()
})
})
})
})
})
function __guard__(value, transform) {
return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
}
return typeof value !== 'undefined' && value !== null
? transform(value)
: undefined
}