mirror of
https://github.com/overleaf/overleaf.git
synced 2025-02-15 01:00:54 +00:00
415 lines
12 KiB
JavaScript
415 lines
12 KiB
JavaScript
/* eslint-disable
|
|
node/handle-callback-err,
|
|
max-len,
|
|
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
|
|
* DS206: Consider reworking classes to avoid initClass
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
const sinon = require('sinon')
|
|
const chai = require('chai')
|
|
const should = chai.should()
|
|
const { expect } = chai
|
|
const modulePath = '../../../../app/src/Features/Compile/CompileManager.js'
|
|
const { assert } = require('chai')
|
|
const SandboxedModule = require('sandboxed-module')
|
|
|
|
describe('CompileManager', function() {
|
|
beforeEach(function() {
|
|
let Timer
|
|
this.rateLimitGetStub = sinon.stub()
|
|
const { rateLimitGetStub } = this
|
|
this.ratelimiter = { addCount: sinon.stub() }
|
|
this.CompileManager = SandboxedModule.require(modulePath, {
|
|
globals: {
|
|
console: console
|
|
},
|
|
requires: {
|
|
'settings-sharelatex': (this.settings = {
|
|
redis: { web: { host: 'localhost', port: 42 } },
|
|
rateLimit: { autoCompile: {} }
|
|
}),
|
|
'../../infrastructure/RedisWrapper': {
|
|
client: () => {
|
|
return (this.rclient = { auth() {} })
|
|
}
|
|
},
|
|
'../Project/ProjectRootDocManager': (this.ProjectRootDocManager = {}),
|
|
'../Project/ProjectGetter': (this.ProjectGetter = {}),
|
|
'../User/UserGetter': (this.UserGetter = {}),
|
|
'./ClsiManager': (this.ClsiManager = {}),
|
|
'../../infrastructure/RateLimiter': this.ratelimiter,
|
|
'@overleaf/metrics': (this.Metrics = {
|
|
Timer: (Timer = (function() {
|
|
Timer = class Timer {
|
|
static initClass() {
|
|
this.prototype.done = sinon.stub()
|
|
}
|
|
}
|
|
Timer.initClass()
|
|
return Timer
|
|
})()),
|
|
inc: sinon.stub()
|
|
}),
|
|
'logger-sharelatex': (this.logger = {
|
|
log: sinon.stub(),
|
|
warn: sinon.stub()
|
|
})
|
|
}
|
|
})
|
|
this.project_id = 'mock-project-id-123'
|
|
this.user_id = 'mock-user-id-123'
|
|
this.callback = sinon.stub()
|
|
return (this.limits = {
|
|
timeout: 42
|
|
})
|
|
})
|
|
|
|
describe('compile', function() {
|
|
beforeEach(function() {
|
|
this.CompileManager._checkIfRecentlyCompiled = sinon
|
|
.stub()
|
|
.callsArgWith(2, null, false)
|
|
this.ProjectRootDocManager.ensureRootDocumentIsSet = sinon
|
|
.stub()
|
|
.callsArgWith(1, null)
|
|
this.CompileManager.getProjectCompileLimits = sinon
|
|
.stub()
|
|
.callsArgWith(1, null, this.limits)
|
|
return (this.ClsiManager.sendRequest = sinon
|
|
.stub()
|
|
.callsArgWith(
|
|
3,
|
|
null,
|
|
(this.status = 'mock-status'),
|
|
(this.outputFiles = 'mock output files'),
|
|
(this.output = 'mock output')
|
|
))
|
|
})
|
|
|
|
describe('succesfully', function() {
|
|
beforeEach(function() {
|
|
this.CompileManager._checkIfAutoCompileLimitHasBeenHit = (
|
|
isAutoCompile,
|
|
compileGroup,
|
|
cb
|
|
) => cb(null, true)
|
|
return this.CompileManager.compile(
|
|
this.project_id,
|
|
this.user_id,
|
|
{},
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should check the project has not been recently compiled', function() {
|
|
return this.CompileManager._checkIfRecentlyCompiled
|
|
.calledWith(this.project_id, this.user_id)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should ensure that the root document is set', function() {
|
|
return this.ProjectRootDocManager.ensureRootDocumentIsSet
|
|
.calledWith(this.project_id)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should get the project compile limits', function() {
|
|
return this.CompileManager.getProjectCompileLimits
|
|
.calledWith(this.project_id)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should run the compile with the compile limits', function() {
|
|
return this.ClsiManager.sendRequest
|
|
.calledWith(this.project_id, this.user_id, {
|
|
timeout: this.limits.timeout
|
|
})
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should call the callback with the output', function() {
|
|
return this.callback
|
|
.calledWith(null, this.status, this.outputFiles, this.output)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should time the compile', function() {
|
|
return this.Metrics.Timer.prototype.done.called.should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('when the project has been recently compiled', function() {
|
|
it('should return', function(done) {
|
|
this.CompileManager._checkIfAutoCompileLimitHasBeenHit = (
|
|
isAutoCompile,
|
|
compileGroup,
|
|
cb
|
|
) => cb(null, true)
|
|
this.CompileManager._checkIfRecentlyCompiled = sinon
|
|
.stub()
|
|
.callsArgWith(2, null, true)
|
|
return this.CompileManager.compile(
|
|
this.project_id,
|
|
this.user_id,
|
|
{},
|
|
(err, status) => {
|
|
status.should.equal('too-recently-compiled')
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('should check the rate limit', function() {
|
|
it('should return', function(done) {
|
|
this.CompileManager._checkIfAutoCompileLimitHasBeenHit = sinon
|
|
.stub()
|
|
.callsArgWith(2, null, false)
|
|
return this.CompileManager.compile(
|
|
this.project_id,
|
|
this.user_id,
|
|
{},
|
|
(err, status) => {
|
|
status.should.equal('autocompile-backoff')
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('getProjectCompileLimits', function() {
|
|
beforeEach(function() {
|
|
this.features = {
|
|
compileTimeout: (this.timeout = 42),
|
|
compileGroup: (this.group = 'priority')
|
|
}
|
|
this.ProjectGetter.getProject = sinon
|
|
.stub()
|
|
.callsArgWith(
|
|
2,
|
|
null,
|
|
(this.project = { owner_ref: (this.owner_id = 'owner-id-123') })
|
|
)
|
|
this.UserGetter.getUser = sinon
|
|
.stub()
|
|
.callsArgWith(2, null, (this.user = { features: this.features }))
|
|
return this.CompileManager.getProjectCompileLimits(
|
|
this.project_id,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should look up the owner of the project', function() {
|
|
return this.ProjectGetter.getProject
|
|
.calledWith(this.project_id, { owner_ref: 1 })
|
|
.should.equal(true)
|
|
})
|
|
|
|
it("should look up the owner's features", function() {
|
|
return this.UserGetter.getUser
|
|
.calledWith(this.project.owner_ref, {
|
|
alphaProgram: 1,
|
|
betaProgram: 1,
|
|
features: 1
|
|
})
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should return the limits', function() {
|
|
return this.callback
|
|
.calledWith(null, {
|
|
timeout: this.timeout,
|
|
compileGroup: this.group
|
|
})
|
|
.should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('deleteAuxFiles', function() {
|
|
beforeEach(function() {
|
|
this.CompileManager.getProjectCompileLimits = sinon
|
|
.stub()
|
|
.callsArgWith(
|
|
1,
|
|
null,
|
|
(this.limits = { compileGroup: 'mock-compile-group' })
|
|
)
|
|
this.ClsiManager.deleteAuxFiles = sinon.stub().callsArg(3)
|
|
return this.CompileManager.deleteAuxFiles(
|
|
this.project_id,
|
|
this.user_id,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should look up the compile group to use', function() {
|
|
return this.CompileManager.getProjectCompileLimits
|
|
.calledWith(this.project_id)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should delete the aux files', function() {
|
|
return this.ClsiManager.deleteAuxFiles
|
|
.calledWith(this.project_id, this.user_id, this.limits)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should call the callback', function() {
|
|
return this.callback.called.should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('_checkIfRecentlyCompiled', function() {
|
|
describe('when the key exists in redis', function() {
|
|
beforeEach(function() {
|
|
this.rclient.set = sinon.stub().callsArgWith(5, null, null)
|
|
return this.CompileManager._checkIfRecentlyCompiled(
|
|
this.project_id,
|
|
this.user_id,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should try to set the key', function() {
|
|
return this.rclient.set
|
|
.calledWith(
|
|
`compile:${this.project_id}:${this.user_id}`,
|
|
true,
|
|
'EX',
|
|
this.CompileManager.COMPILE_DELAY,
|
|
'NX'
|
|
)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should call the callback with true', function() {
|
|
return this.callback.calledWith(null, true).should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('when the key does not exist in redis', function() {
|
|
beforeEach(function() {
|
|
this.rclient.set = sinon.stub().callsArgWith(5, null, 'OK')
|
|
return this.CompileManager._checkIfRecentlyCompiled(
|
|
this.project_id,
|
|
this.user_id,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should try to set the key', function() {
|
|
return this.rclient.set
|
|
.calledWith(
|
|
`compile:${this.project_id}:${this.user_id}`,
|
|
true,
|
|
'EX',
|
|
this.CompileManager.COMPILE_DELAY,
|
|
'NX'
|
|
)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should call the callback with false', function() {
|
|
return this.callback.calledWith(null, false).should.equal(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('_checkIfAutoCompileLimitHasBeenHit', function() {
|
|
it('should be able to compile if it is not an autocompile', function(done) {
|
|
this.ratelimiter.addCount.callsArgWith(2, null, true)
|
|
return this.CompileManager._checkIfAutoCompileLimitHasBeenHit(
|
|
false,
|
|
'everyone',
|
|
(err, canCompile) => {
|
|
canCompile.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should be able to compile if rate limit has remianing', function(done) {
|
|
this.ratelimiter.addCount.callsArgWith(1, null, true)
|
|
return this.CompileManager._checkIfAutoCompileLimitHasBeenHit(
|
|
true,
|
|
'everyone',
|
|
(err, canCompile) => {
|
|
const args = this.ratelimiter.addCount.args[0][0]
|
|
args.throttle.should.equal(25)
|
|
args.subjectName.should.equal('everyone')
|
|
args.timeInterval.should.equal(20)
|
|
args.endpointName.should.equal('auto_compile')
|
|
canCompile.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should be not able to compile if rate limit has no remianing', function(done) {
|
|
this.ratelimiter.addCount.callsArgWith(1, null, false)
|
|
return this.CompileManager._checkIfAutoCompileLimitHasBeenHit(
|
|
true,
|
|
'everyone',
|
|
(err, canCompile) => {
|
|
canCompile.should.equal(false)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should return false if there is an error in the rate limit', function(done) {
|
|
this.ratelimiter.addCount.callsArgWith(1, 'error')
|
|
return this.CompileManager._checkIfAutoCompileLimitHasBeenHit(
|
|
true,
|
|
'everyone',
|
|
(err, canCompile) => {
|
|
canCompile.should.equal(false)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('wordCount', function() {
|
|
beforeEach(function() {
|
|
this.CompileManager.getProjectCompileLimits = sinon
|
|
.stub()
|
|
.callsArgWith(
|
|
1,
|
|
null,
|
|
(this.limits = { compileGroup: 'mock-compile-group' })
|
|
)
|
|
this.ClsiManager.wordCount = sinon.stub().callsArg(4)
|
|
return this.CompileManager.wordCount(
|
|
this.project_id,
|
|
this.user_id,
|
|
false,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should look up the compile group to use', function() {
|
|
return this.CompileManager.getProjectCompileLimits
|
|
.calledWith(this.project_id)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should call wordCount for project', function() {
|
|
return this.ClsiManager.wordCount
|
|
.calledWith(this.project_id, this.user_id, false, this.limits)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should call the callback', function() {
|
|
return this.callback.called.should.equal(true)
|
|
})
|
|
})
|
|
})
|