overleaf/libraries/metrics/test/unit/js/timeAsyncMethodTests.js
Jakob Ackermann 4b308553be Merge pull request #6120 from overleaf/jpa-same-linting-packages
[misc] move the linting setup to the root of the monorepo

GitOrigin-RevId: 1633e2a58598add0b727738cd3bfba0ab7bae781
2021-12-17 09:03:06 +00:00

201 lines
5.7 KiB
JavaScript

/*
* 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 chai = require('chai')
const { expect } = chai
const path = require('path')
const modulePath = path.join(__dirname, '../../../timeAsyncMethod.js')
const SandboxedModule = require('sandboxed-module')
const sinon = require('sinon')
describe('timeAsyncMethod', function () {
beforeEach(function () {
this.Timer = { done: sinon.stub() }
this.TimerConstructor = sinon.stub().returns(this.Timer)
this.metrics = {
Timer: this.TimerConstructor,
inc: sinon.stub(),
}
this.timeAsyncMethod = SandboxedModule.require(modulePath, {
requires: {
'./index': this.metrics,
},
})
return (this.testObject = {
nextNumber(n, callback) {
return setTimeout(() => callback(null, n + 1), 100)
},
})
})
it('should have the testObject behave correctly before wrapping', function (done) {
return this.testObject.nextNumber(2, (err, result) => {
expect(err).to.not.exist
expect(result).to.equal(3)
return done()
})
})
it('should wrap method without error', function (done) {
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject'
)
return done()
})
it('should transparently wrap method invocation in timer', function (done) {
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject'
)
return this.testObject.nextNumber(2, (err, result) => {
expect(err).to.not.exist
expect(result).to.equal(3)
expect(this.TimerConstructor.callCount).to.equal(1)
expect(this.Timer.done.callCount).to.equal(1)
return done()
})
})
it('should increment success count', function (done) {
this.metrics.inc = sinon.stub()
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject'
)
return this.testObject.nextNumber(2, (err, result) => {
if (err) {
return done(err)
}
expect(this.metrics.inc.callCount).to.equal(1)
expect(
this.metrics.inc.calledWith('someContext_result', 1, {
method: 'TestObject_nextNumber',
status: 'success',
})
).to.equal(true)
return done()
})
})
describe('when base method produces an error', function () {
beforeEach(function () {
this.metrics.inc = sinon.stub()
return (this.testObject.nextNumber = function (n, callback) {
return setTimeout(() => callback(new Error('woops')), 100)
})
})
it('should propagate the error transparently', function (done) {
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject'
)
return this.testObject.nextNumber(2, (err, result) => {
expect(err).to.exist
expect(err).to.be.instanceof(Error)
expect(result).to.not.exist
return done()
})
})
return it('should increment failure count', function (done) {
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject'
)
return this.testObject.nextNumber(2, (err, result) => {
expect(err).to.exist
expect(this.metrics.inc.callCount).to.equal(1)
expect(
this.metrics.inc.calledWith('someContext_result', 1, {
method: 'TestObject_nextNumber',
status: 'failed',
})
).to.equal(true)
return done()
})
})
})
describe('when a logger is supplied', function () {
beforeEach(function () {
return (this.logger = { log: sinon.stub() })
})
return it('should also call logger.log', function (done) {
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject',
this.logger
)
return this.testObject.nextNumber(2, (err, result) => {
expect(err).to.not.exist
expect(result).to.equal(3)
expect(this.TimerConstructor.callCount).to.equal(1)
expect(this.Timer.done.callCount).to.equal(1)
expect(this.logger.log.callCount).to.equal(1)
return done()
})
})
})
describe('when the wrapper cannot be applied', function () {
beforeEach(function () {})
return it('should raise an error', function () {
const badWrap = () => {
return this.timeAsyncMethod(
this.testObject,
'DEFINITELY_NOT_A_REAL_METHOD',
'someContext.TestObject'
)
}
return expect(badWrap).to.throw(
/^.*expected object property 'DEFINITELY_NOT_A_REAL_METHOD' to be a function.*$/
)
})
})
return describe('when the wrapped function is not using a callback', function () {
beforeEach(function () {
this.realMethod = sinon.stub().returns(42)
return (this.testObject.nextNumber = this.realMethod)
})
it('should not throw an error', function () {
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject'
)
const badCall = () => {
return this.testObject.nextNumber(2)
}
return expect(badCall).to.not.throw(Error)
})
return it('should call the underlying method', function () {
this.timeAsyncMethod(
this.testObject,
'nextNumber',
'someContext.TestObject'
)
const result = this.testObject.nextNumber(12)
expect(this.realMethod.callCount).to.equal(1)
expect(this.realMethod.calledWith(12)).to.equal(true)
return expect(result).to.equal(42)
})
})
})