mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-16 02:52:31 -04:00
902 lines
28 KiB
JavaScript
902 lines
28 KiB
JavaScript
/* eslint-disable
|
|
handle-callback-err,
|
|
no-return-assign,
|
|
no-unused-vars,
|
|
*/
|
|
// TODO: This file was created by bulk-decaffeinate.
|
|
// Fix any style issues and re-enable lint.
|
|
/*
|
|
* decaffeinate suggestions:
|
|
* DS101: Remove unnecessary use of Array.from
|
|
* DS102: Remove unnecessary code created because of implicit returns
|
|
* DS206: Consider reworking classes to avoid initClass
|
|
* DS207: Consider shorter variations of null checks
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
const SandboxedModule = require('sandboxed-module')
|
|
const sinon = require('sinon')
|
|
require('chai').should()
|
|
const { expect } = require('chai')
|
|
const modulePath = require('path').join(
|
|
__dirname,
|
|
'../../../app/js/DockerRunner'
|
|
)
|
|
const Path = require('path')
|
|
|
|
describe('DockerRunner', function() {
|
|
beforeEach(function() {
|
|
let container, Docker, Timer
|
|
this.container = container = {}
|
|
this.DockerRunner = SandboxedModule.require(modulePath, {
|
|
requires: {
|
|
'settings-sharelatex': (this.Settings = {
|
|
clsi: { docker: {} },
|
|
path: {}
|
|
}),
|
|
'logger-sharelatex': (this.logger = {
|
|
log: sinon.stub(),
|
|
error: sinon.stub(),
|
|
err: sinon.stub(),
|
|
info: sinon.stub(),
|
|
warn: sinon.stub()
|
|
}),
|
|
dockerode: (Docker = (function() {
|
|
Docker = class Docker {
|
|
static initClass() {
|
|
this.prototype.getContainer = sinon.stub().returns(container)
|
|
this.prototype.createContainer = sinon
|
|
.stub()
|
|
.yields(null, container)
|
|
this.prototype.listContainers = sinon.stub()
|
|
}
|
|
}
|
|
Docker.initClass()
|
|
return Docker
|
|
})()),
|
|
fs: (this.fs = {
|
|
stat: sinon.stub().yields(null, {
|
|
isDirectory() {
|
|
return true
|
|
}
|
|
})
|
|
}),
|
|
'./Metrics': {
|
|
Timer: (Timer = class Timer {
|
|
done() {}
|
|
})
|
|
},
|
|
'./LockManager': {
|
|
runWithLock(key, runner, callback) {
|
|
return runner(callback)
|
|
}
|
|
}
|
|
},
|
|
globals: { Math } // used by lodash
|
|
})
|
|
this.Docker = Docker
|
|
this.getContainer = Docker.prototype.getContainer
|
|
this.createContainer = Docker.prototype.createContainer
|
|
this.listContainers = Docker.prototype.listContainers
|
|
|
|
this.directory = '/local/compile/directory'
|
|
this.mainFile = 'main-file.tex'
|
|
this.compiler = 'pdflatex'
|
|
this.image = 'example.com/sharelatex/image:2016.2'
|
|
this.env = {}
|
|
this.callback = sinon.stub()
|
|
this.project_id = 'project-id-123'
|
|
this.volumes = { '/local/compile/directory': '/compile' }
|
|
this.Settings.clsi.docker.image = this.defaultImage = 'default-image'
|
|
return (this.Settings.clsi.docker.env = { PATH: 'mock-path' })
|
|
})
|
|
|
|
afterEach(function() {
|
|
this.DockerRunner.stopContainerMonitor()
|
|
})
|
|
|
|
describe('run', function() {
|
|
beforeEach(function(done) {
|
|
this.DockerRunner._getContainerOptions = sinon
|
|
.stub()
|
|
.returns((this.options = { mockoptions: 'foo' }))
|
|
this.DockerRunner._fingerprintContainer = sinon
|
|
.stub()
|
|
.returns((this.fingerprint = 'fingerprint'))
|
|
|
|
this.name = `project-${this.project_id}-${this.fingerprint}`
|
|
|
|
this.command = ['mock', 'command', '--outdir=$COMPILE_DIR']
|
|
this.command_with_dir = ['mock', 'command', '--outdir=/compile']
|
|
this.timeout = 42000
|
|
return done()
|
|
})
|
|
|
|
describe('successfully', function() {
|
|
beforeEach(function(done) {
|
|
this.DockerRunner._runAndWaitForContainer = sinon
|
|
.stub()
|
|
.callsArgWith(3, null, (this.output = 'mock-output'))
|
|
return this.DockerRunner.run(
|
|
this.project_id,
|
|
this.command,
|
|
this.directory,
|
|
this.image,
|
|
this.timeout,
|
|
this.env,
|
|
(err, output) => {
|
|
this.callback(err, output)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should generate the options for the container', function() {
|
|
return this.DockerRunner._getContainerOptions
|
|
.calledWith(
|
|
this.command_with_dir,
|
|
this.image,
|
|
this.volumes,
|
|
this.timeout
|
|
)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should generate the fingerprint from the returned options', function() {
|
|
return this.DockerRunner._fingerprintContainer
|
|
.calledWith(this.options)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should do the run', function() {
|
|
return this.DockerRunner._runAndWaitForContainer
|
|
.calledWith(this.options, this.volumes, this.timeout)
|
|
.should.equal(true)
|
|
})
|
|
|
|
return it('should call the callback', function() {
|
|
return this.callback.calledWith(null, this.output).should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('when path.sandboxedCompilesHostDir is set', function() {
|
|
beforeEach(function() {
|
|
this.Settings.path.sandboxedCompilesHostDir = '/some/host/dir/compiles'
|
|
this.directory = '/var/lib/sharelatex/data/compiles/xyz'
|
|
this.DockerRunner._runAndWaitForContainer = sinon
|
|
.stub()
|
|
.callsArgWith(3, null, (this.output = 'mock-output'))
|
|
return this.DockerRunner.run(
|
|
this.project_id,
|
|
this.command,
|
|
this.directory,
|
|
this.image,
|
|
this.timeout,
|
|
this.env,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should re-write the bind directory', function() {
|
|
const volumes = this.DockerRunner._runAndWaitForContainer.lastCall
|
|
.args[1]
|
|
return expect(volumes).to.deep.equal({
|
|
'/some/host/dir/compiles/xyz': '/compile'
|
|
})
|
|
})
|
|
|
|
return it('should call the callback', function() {
|
|
return this.callback.calledWith(null, this.output).should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('when the run throws an error', function() {
|
|
beforeEach(function() {
|
|
let firstTime = true
|
|
this.output = 'mock-output'
|
|
this.DockerRunner._runAndWaitForContainer = (
|
|
options,
|
|
volumes,
|
|
timeout,
|
|
callback
|
|
) => {
|
|
if (callback == null) {
|
|
callback = function(error, output) {}
|
|
}
|
|
if (firstTime) {
|
|
firstTime = false
|
|
const error = new Error('(HTTP code 500) server error - ...')
|
|
error.statusCode = 500
|
|
return callback(error)
|
|
} else {
|
|
return callback(null, this.output)
|
|
}
|
|
}
|
|
sinon.spy(this.DockerRunner, '_runAndWaitForContainer')
|
|
this.DockerRunner.destroyContainer = sinon.stub().callsArg(3)
|
|
return this.DockerRunner.run(
|
|
this.project_id,
|
|
this.command,
|
|
this.directory,
|
|
this.image,
|
|
this.timeout,
|
|
this.env,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should do the run twice', function() {
|
|
return this.DockerRunner._runAndWaitForContainer.calledTwice.should.equal(
|
|
true
|
|
)
|
|
})
|
|
|
|
it('should destroy the container in between', function() {
|
|
return this.DockerRunner.destroyContainer
|
|
.calledWith(this.name, null)
|
|
.should.equal(true)
|
|
})
|
|
|
|
return it('should call the callback', function() {
|
|
return this.callback.calledWith(null, this.output).should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('with no image', function() {
|
|
beforeEach(function() {
|
|
this.DockerRunner._runAndWaitForContainer = sinon
|
|
.stub()
|
|
.callsArgWith(3, null, (this.output = 'mock-output'))
|
|
return this.DockerRunner.run(
|
|
this.project_id,
|
|
this.command,
|
|
this.directory,
|
|
null,
|
|
this.timeout,
|
|
this.env,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
return it('should use the default image', function() {
|
|
return this.DockerRunner._getContainerOptions
|
|
.calledWith(
|
|
this.command_with_dir,
|
|
this.defaultImage,
|
|
this.volumes,
|
|
this.timeout
|
|
)
|
|
.should.equal(true)
|
|
})
|
|
})
|
|
|
|
return describe('with image override', function() {
|
|
beforeEach(function() {
|
|
this.Settings.texliveImageNameOveride = 'overrideimage.com/something'
|
|
this.DockerRunner._runAndWaitForContainer = sinon
|
|
.stub()
|
|
.callsArgWith(3, null, (this.output = 'mock-output'))
|
|
return this.DockerRunner.run(
|
|
this.project_id,
|
|
this.command,
|
|
this.directory,
|
|
this.image,
|
|
this.timeout,
|
|
this.env,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
return it('should use the override and keep the tag', function() {
|
|
const image = this.DockerRunner._getContainerOptions.args[0][1]
|
|
return image.should.equal('overrideimage.com/something/image:2016.2')
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('_runAndWaitForContainer', function() {
|
|
beforeEach(function() {
|
|
this.options = { mockoptions: 'foo', name: (this.name = 'mock-name') }
|
|
this.DockerRunner.startContainer = (
|
|
options,
|
|
volumes,
|
|
attachStreamHandler,
|
|
callback
|
|
) => {
|
|
attachStreamHandler(null, (this.output = 'mock-output'))
|
|
return callback(null, (this.containerId = 'container-id'))
|
|
}
|
|
sinon.spy(this.DockerRunner, 'startContainer')
|
|
this.DockerRunner.waitForContainer = sinon
|
|
.stub()
|
|
.callsArgWith(2, null, (this.exitCode = 42))
|
|
return this.DockerRunner._runAndWaitForContainer(
|
|
this.options,
|
|
this.volumes,
|
|
this.timeout,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should create/start the container', function() {
|
|
return this.DockerRunner.startContainer
|
|
.calledWith(this.options, this.volumes)
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should wait for the container to finish', function() {
|
|
return this.DockerRunner.waitForContainer
|
|
.calledWith(this.name, this.timeout)
|
|
.should.equal(true)
|
|
})
|
|
|
|
return it('should call the callback with the output', function() {
|
|
return this.callback.calledWith(null, this.output).should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('startContainer', function() {
|
|
beforeEach(function() {
|
|
this.attachStreamHandler = sinon.stub()
|
|
this.attachStreamHandler.cock = true
|
|
this.options = { mockoptions: 'foo', name: 'mock-name' }
|
|
this.container.inspect = sinon.stub().callsArgWith(0)
|
|
this.DockerRunner.attachToContainer = (
|
|
containerId,
|
|
attachStreamHandler,
|
|
cb
|
|
) => {
|
|
attachStreamHandler()
|
|
return cb()
|
|
}
|
|
return sinon.spy(this.DockerRunner, 'attachToContainer')
|
|
})
|
|
|
|
describe('when the container exists', function() {
|
|
beforeEach(function() {
|
|
this.container.inspect = sinon.stub().callsArgWith(0)
|
|
this.container.start = sinon.stub().yields()
|
|
|
|
return this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
() => {},
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should start the container with the given name', function() {
|
|
this.getContainer.calledWith(this.options.name).should.equal(true)
|
|
return this.container.start.called.should.equal(true)
|
|
})
|
|
|
|
it('should not try to create the container', function() {
|
|
return this.createContainer.called.should.equal(false)
|
|
})
|
|
|
|
it('should attach to the container', function() {
|
|
return this.DockerRunner.attachToContainer.called.should.equal(true)
|
|
})
|
|
|
|
it('should call the callback', function() {
|
|
return this.callback.called.should.equal(true)
|
|
})
|
|
|
|
return it('should attach before the container starts', function() {
|
|
return sinon.assert.callOrder(
|
|
this.DockerRunner.attachToContainer,
|
|
this.container.start
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when inspect always fails with EPIPE error', function() {
|
|
beforeEach(function() {
|
|
this.error = new Error('write EPIPE')
|
|
this.container.inspect = sinon.stub().yields(this.error)
|
|
this.container.start = sinon.stub().yields()
|
|
|
|
this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
() => {},
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should retry once', function() {
|
|
sinon.assert.callOrder(
|
|
this.container.inspect,
|
|
this.container.inspect,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should call back with error', function() {
|
|
sinon.assert.calledWith(this.callback, this.error)
|
|
})
|
|
})
|
|
|
|
describe('when inspect fails once with EPIPE error', function() {
|
|
beforeEach(function() {
|
|
this.container.inspect = sinon.stub()
|
|
this.container.inspect.onFirstCall().yields(new Error('write EPIPE'))
|
|
this.container.inspect.onSecondCall().yields()
|
|
this.container.start = sinon.stub().yields()
|
|
|
|
this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
() => {},
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should retry once and start container', function() {
|
|
sinon.assert.callOrder(
|
|
this.container.inspect,
|
|
this.container.inspect,
|
|
this.DockerRunner.attachToContainer,
|
|
this.container.start,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should call back without error', function() {
|
|
sinon.assert.calledWith(this.callback, null)
|
|
})
|
|
})
|
|
|
|
describe('when the container does not exist', function() {
|
|
beforeEach(function() {
|
|
const exists = false
|
|
this.container.start = sinon.stub().yields()
|
|
this.container.inspect = sinon
|
|
.stub()
|
|
.callsArgWith(0, { statusCode: 404 })
|
|
return this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
this.attachStreamHandler,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should create the container', function() {
|
|
return this.createContainer.calledWith(this.options).should.equal(true)
|
|
})
|
|
|
|
it('should call the callback and stream handler', function() {
|
|
this.attachStreamHandler.called.should.equal(true)
|
|
return this.callback.called.should.equal(true)
|
|
})
|
|
|
|
it('should attach to the container', function() {
|
|
return this.DockerRunner.attachToContainer.called.should.equal(true)
|
|
})
|
|
|
|
return it('should attach before the container starts', function() {
|
|
return sinon.assert.callOrder(
|
|
this.DockerRunner.attachToContainer,
|
|
this.container.start
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when the container is already running', function() {
|
|
beforeEach(function() {
|
|
const error = new Error(
|
|
`HTTP code is 304 which indicates error: server error - start: Cannot start container ${this.name}: The container MOCKID is already running.`
|
|
)
|
|
error.statusCode = 304
|
|
this.container.start = sinon.stub().yields(error)
|
|
this.container.inspect = sinon.stub().callsArgWith(0)
|
|
return this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
this.attachStreamHandler,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should not try to create the container', function() {
|
|
return this.createContainer.called.should.equal(false)
|
|
})
|
|
|
|
return it('should call the callback and stream handler without an error', function() {
|
|
this.attachStreamHandler.called.should.equal(true)
|
|
return this.callback.called.should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('when a volume does not exist', function() {
|
|
beforeEach(function() {
|
|
this.fs.stat = sinon.stub().yields(new Error('no such path'))
|
|
return this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
this.attachStreamHandler,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should not try to create the container', function() {
|
|
return this.createContainer.called.should.equal(false)
|
|
})
|
|
|
|
it('should call the callback with an error', function() {
|
|
this.callback.calledWith(sinon.match(Error)).should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('when a volume exists but is not a directory', function() {
|
|
beforeEach(function() {
|
|
this.fs.stat = sinon.stub().yields(null, {
|
|
isDirectory() {
|
|
return false
|
|
}
|
|
})
|
|
return this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
this.attachStreamHandler,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should not try to create the container', function() {
|
|
return this.createContainer.called.should.equal(false)
|
|
})
|
|
|
|
it('should call the callback with an error', function() {
|
|
this.callback.calledWith(sinon.match(Error)).should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('when a volume does not exist, but sibling-containers are used', function() {
|
|
beforeEach(function() {
|
|
this.fs.stat = sinon.stub().yields(new Error('no such path'))
|
|
this.Settings.path.sandboxedCompilesHostDir = '/some/path'
|
|
this.container.start = sinon.stub().yields()
|
|
return this.DockerRunner.startContainer(
|
|
this.options,
|
|
this.volumes,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
afterEach(function() {
|
|
return delete this.Settings.path.sandboxedCompilesHostDir
|
|
})
|
|
|
|
it('should start the container with the given name', function() {
|
|
this.getContainer.calledWith(this.options.name).should.equal(true)
|
|
return this.container.start.called.should.equal(true)
|
|
})
|
|
|
|
it('should not try to create the container', function() {
|
|
return this.createContainer.called.should.equal(false)
|
|
})
|
|
|
|
return it('should call the callback', function() {
|
|
this.callback.called.should.equal(true)
|
|
return this.callback.calledWith(new Error()).should.equal(false)
|
|
})
|
|
})
|
|
|
|
return describe('when the container tries to be created, but already has been (race condition)', function() {})
|
|
})
|
|
|
|
describe('waitForContainer', function() {
|
|
beforeEach(function() {
|
|
this.containerId = 'container-id'
|
|
this.timeout = 5000
|
|
this.container.wait = sinon
|
|
.stub()
|
|
.yields(null, { StatusCode: (this.statusCode = 42) })
|
|
return (this.container.kill = sinon.stub().yields())
|
|
})
|
|
|
|
describe('when the container returns in time', function() {
|
|
beforeEach(function() {
|
|
return this.DockerRunner.waitForContainer(
|
|
this.containerId,
|
|
this.timeout,
|
|
this.callback
|
|
)
|
|
})
|
|
|
|
it('should wait for the container', function() {
|
|
this.getContainer.calledWith(this.containerId).should.equal(true)
|
|
return this.container.wait.called.should.equal(true)
|
|
})
|
|
|
|
return it('should call the callback with the exit', function() {
|
|
return this.callback
|
|
.calledWith(null, this.statusCode)
|
|
.should.equal(true)
|
|
})
|
|
})
|
|
|
|
return describe('when the container does not return before the timeout', function() {
|
|
beforeEach(function(done) {
|
|
this.container.wait = function(callback) {
|
|
if (callback == null) {
|
|
callback = function(error, exitCode) {}
|
|
}
|
|
return setTimeout(() => callback(null, { StatusCode: 42 }), 100)
|
|
}
|
|
this.timeout = 5
|
|
return this.DockerRunner.waitForContainer(
|
|
this.containerId,
|
|
this.timeout,
|
|
(...args) => {
|
|
this.callback(...Array.from(args || []))
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should call kill on the container', function() {
|
|
this.getContainer.calledWith(this.containerId).should.equal(true)
|
|
return this.container.kill.called.should.equal(true)
|
|
})
|
|
|
|
it('should call the callback with an error', function() {
|
|
this.callback.calledWith(sinon.match(Error)).should.equal(true)
|
|
|
|
const errorObj = this.callback.args[0][0]
|
|
expect(errorObj.message).to.include('container timed out')
|
|
expect(errorObj.timedout).equal(true)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('destroyOldContainers', function() {
|
|
beforeEach(function(done) {
|
|
const oneHourInSeconds = 60 * 60
|
|
const oneHourInMilliseconds = oneHourInSeconds * 1000
|
|
const nowInSeconds = Date.now() / 1000
|
|
this.containers = [
|
|
{
|
|
Name: '/project-old-container-name',
|
|
Id: 'old-container-id',
|
|
Created: nowInSeconds - oneHourInSeconds - 100
|
|
},
|
|
{
|
|
Name: '/project-new-container-name',
|
|
Id: 'new-container-id',
|
|
Created: nowInSeconds - oneHourInSeconds + 100
|
|
},
|
|
{
|
|
Name: '/totally-not-a-project-container',
|
|
Id: 'some-random-id',
|
|
Created: nowInSeconds - 2 * oneHourInSeconds
|
|
}
|
|
]
|
|
this.DockerRunner.MAX_CONTAINER_AGE = oneHourInMilliseconds
|
|
this.listContainers.callsArgWith(1, null, this.containers)
|
|
this.DockerRunner.destroyContainer = sinon.stub().callsArg(3)
|
|
return this.DockerRunner.destroyOldContainers(error => {
|
|
this.callback(error)
|
|
return done()
|
|
})
|
|
})
|
|
|
|
it('should list all containers', function() {
|
|
return this.listContainers.calledWith({ all: true }).should.equal(true)
|
|
})
|
|
|
|
it('should destroy old containers', function() {
|
|
this.DockerRunner.destroyContainer.callCount.should.equal(1)
|
|
return this.DockerRunner.destroyContainer
|
|
.calledWith('project-old-container-name', 'old-container-id')
|
|
.should.equal(true)
|
|
})
|
|
|
|
it('should not destroy new containers', function() {
|
|
return this.DockerRunner.destroyContainer
|
|
.calledWith('project-new-container-name', 'new-container-id')
|
|
.should.equal(false)
|
|
})
|
|
|
|
it('should not destroy non-project containers', function() {
|
|
return this.DockerRunner.destroyContainer
|
|
.calledWith('totally-not-a-project-container', 'some-random-id')
|
|
.should.equal(false)
|
|
})
|
|
|
|
return it('should callback the callback', function() {
|
|
return this.callback.called.should.equal(true)
|
|
})
|
|
})
|
|
|
|
describe('_destroyContainer', function() {
|
|
beforeEach(function() {
|
|
this.containerId = 'some_id'
|
|
this.fakeContainer = { remove: sinon.stub().callsArgWith(1, null) }
|
|
return (this.Docker.prototype.getContainer = sinon
|
|
.stub()
|
|
.returns(this.fakeContainer))
|
|
})
|
|
|
|
it('should get the container', function(done) {
|
|
return this.DockerRunner._destroyContainer(
|
|
this.containerId,
|
|
false,
|
|
err => {
|
|
this.Docker.prototype.getContainer.callCount.should.equal(1)
|
|
this.Docker.prototype.getContainer
|
|
.calledWith(this.containerId)
|
|
.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should try to force-destroy the container when shouldForce=true', function(done) {
|
|
return this.DockerRunner._destroyContainer(
|
|
this.containerId,
|
|
true,
|
|
err => {
|
|
this.fakeContainer.remove.callCount.should.equal(1)
|
|
this.fakeContainer.remove
|
|
.calledWith({ force: true })
|
|
.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should not try to force-destroy the container when shouldForce=false', function(done) {
|
|
return this.DockerRunner._destroyContainer(
|
|
this.containerId,
|
|
false,
|
|
err => {
|
|
this.fakeContainer.remove.callCount.should.equal(1)
|
|
this.fakeContainer.remove
|
|
.calledWith({ force: false })
|
|
.should.equal(true)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
it('should not produce an error', function(done) {
|
|
return this.DockerRunner._destroyContainer(
|
|
this.containerId,
|
|
false,
|
|
err => {
|
|
expect(err).to.equal(null)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
|
|
describe('when the container is already gone', function() {
|
|
beforeEach(function() {
|
|
this.fakeError = new Error('woops')
|
|
this.fakeError.statusCode = 404
|
|
this.fakeContainer = {
|
|
remove: sinon.stub().callsArgWith(1, this.fakeError)
|
|
}
|
|
return (this.Docker.prototype.getContainer = sinon
|
|
.stub()
|
|
.returns(this.fakeContainer))
|
|
})
|
|
|
|
return it('should not produce an error', function(done) {
|
|
return this.DockerRunner._destroyContainer(
|
|
this.containerId,
|
|
false,
|
|
err => {
|
|
expect(err).to.equal(null)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
|
|
return describe('when container.destroy produces an error', function(done) {
|
|
beforeEach(function() {
|
|
this.fakeError = new Error('woops')
|
|
this.fakeError.statusCode = 500
|
|
this.fakeContainer = {
|
|
remove: sinon.stub().callsArgWith(1, this.fakeError)
|
|
}
|
|
return (this.Docker.prototype.getContainer = sinon
|
|
.stub()
|
|
.returns(this.fakeContainer))
|
|
})
|
|
|
|
return it('should produce an error', function(done) {
|
|
return this.DockerRunner._destroyContainer(
|
|
this.containerId,
|
|
false,
|
|
err => {
|
|
expect(err).to.not.equal(null)
|
|
expect(err).to.equal(this.fakeError)
|
|
return done()
|
|
}
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
return describe('kill', function() {
|
|
beforeEach(function() {
|
|
this.containerId = 'some_id'
|
|
this.fakeContainer = { kill: sinon.stub().callsArgWith(0, null) }
|
|
return (this.Docker.prototype.getContainer = sinon
|
|
.stub()
|
|
.returns(this.fakeContainer))
|
|
})
|
|
|
|
it('should get the container', function(done) {
|
|
return this.DockerRunner.kill(this.containerId, err => {
|
|
this.Docker.prototype.getContainer.callCount.should.equal(1)
|
|
this.Docker.prototype.getContainer
|
|
.calledWith(this.containerId)
|
|
.should.equal(true)
|
|
return done()
|
|
})
|
|
})
|
|
|
|
it('should try to force-destroy the container', function(done) {
|
|
return this.DockerRunner.kill(this.containerId, err => {
|
|
this.fakeContainer.kill.callCount.should.equal(1)
|
|
return done()
|
|
})
|
|
})
|
|
|
|
it('should not produce an error', function(done) {
|
|
return this.DockerRunner.kill(this.containerId, err => {
|
|
expect(err).to.equal(undefined)
|
|
return done()
|
|
})
|
|
})
|
|
|
|
describe('when the container is not actually running', function() {
|
|
beforeEach(function() {
|
|
this.fakeError = new Error('woops')
|
|
this.fakeError.statusCode = 500
|
|
this.fakeError.message =
|
|
'Cannot kill container <whatever> is not running'
|
|
this.fakeContainer = {
|
|
kill: sinon.stub().callsArgWith(0, this.fakeError)
|
|
}
|
|
return (this.Docker.prototype.getContainer = sinon
|
|
.stub()
|
|
.returns(this.fakeContainer))
|
|
})
|
|
|
|
return it('should not produce an error', function(done) {
|
|
return this.DockerRunner.kill(this.containerId, err => {
|
|
expect(err).to.equal(undefined)
|
|
return done()
|
|
})
|
|
})
|
|
})
|
|
|
|
return describe('when container.kill produces a legitimate error', function(done) {
|
|
beforeEach(function() {
|
|
this.fakeError = new Error('woops')
|
|
this.fakeError.statusCode = 500
|
|
this.fakeError.message = 'Totally legitimate reason to throw an error'
|
|
this.fakeContainer = {
|
|
kill: sinon.stub().callsArgWith(0, this.fakeError)
|
|
}
|
|
return (this.Docker.prototype.getContainer = sinon
|
|
.stub()
|
|
.returns(this.fakeContainer))
|
|
})
|
|
|
|
return it('should produce an error', function(done) {
|
|
return this.DockerRunner.kill(this.containerId, err => {
|
|
expect(err).to.not.equal(undefined)
|
|
expect(err).to.equal(this.fakeError)
|
|
return done()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|