mirror of
https://github.com/yu-i-i/overleaf-cep.git
synced 2026-11-14 14:13:43 +01:00
314 lines
9.2 KiB
JavaScript
314 lines
9.2 KiB
JavaScript
/* eslint-disable
|
|
handle-callback-err,
|
|
no-path-concat,
|
|
no-return-assign,
|
|
no-unused-vars,
|
|
*/
|
|
// TODO: This file was created by bulk-decaffeinate.
|
|
// Fix any style issues and re-enable lint.
|
|
/*
|
|
* decaffeinate suggestions:
|
|
* DS102: Remove unnecessary code created because of implicit returns
|
|
* 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 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";
|
|
|
|
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);
|
|
});
|
|
});
|
|
|
|
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();
|
|
});
|
|
});
|
|
|
|
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}`;
|
|
|
|
const writeStream = request.post(this.fileUrl);
|
|
|
|
writeStream.on("end", done);
|
|
return fs.createReadStream(this.localFileReadPath).pipe(writeStream);
|
|
});
|
|
|
|
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 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 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 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 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 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 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 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 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();
|
|
});
|
|
});
|
|
});
|
|
|
|
return it("should be able to copy files", function(done){
|
|
this.timeout(1000 * 20);
|
|
|
|
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 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);
|
|
|
|
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.localFileSize);
|
|
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();
|
|
});
|
|
});
|
|
|
|
describe("getting the preview image", function() {
|
|
|
|
beforeEach(function() {
|
|
return this.previewFileUrl = `${this.fileUrl}?style=preview`;
|
|
});
|
|
|
|
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();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
function __guard__(value, transform) {
|
|
return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
|
|
} |