|
|
@@ -202,1488 +202,1488 @@ describe('kernel', () => {
|
|
|
|
|
|
});
|
|
|
|
|
|
- describe('Kernel.connectTo()', () => {
|
|
|
-
|
|
|
- it('should reuse an exisiting kernel', (done) => {
|
|
|
- let id = uuid();
|
|
|
- tester.runningKernels = [{ name: 'foo', id }];
|
|
|
- Kernel.connectTo(id).then(k => {
|
|
|
- kernel = k;
|
|
|
- Kernel.connectTo(id).then(newKernel => {
|
|
|
- expect(newKernel.name).to.be(kernel.name);
|
|
|
- expect(newKernel.id).to.be(kernel.id);
|
|
|
- newKernel.dispose();
|
|
|
- done();
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should connect to a running kernel if given kernel options', (done) => {
|
|
|
- let id = uuid();
|
|
|
- tester.runningKernels = [{ name: KERNEL_OPTIONS.name, id }];
|
|
|
- Kernel.connectTo(id).then(k => {
|
|
|
- kernel = k;
|
|
|
- expect(kernel.name).to.be(KERNEL_OPTIONS.name);
|
|
|
- expect(kernel.id).to.be(id);
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should accept server settings', (done) => {
|
|
|
- let id = uuid();
|
|
|
- tester.runningKernels = [{ name: KERNEL_OPTIONS.name, id }];
|
|
|
- Kernel.connectTo(id, serverSettings).then(k => {
|
|
|
- kernel = k;
|
|
|
- expect(kernel.name).to.be(KERNEL_OPTIONS.name);
|
|
|
- expect(kernel.id).to.be(id);
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should fail if no running kernel available', (done) => {
|
|
|
- let id = uuid();
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(400, { });
|
|
|
- };
|
|
|
- let kernelPromise = Kernel.connectTo(id);
|
|
|
- expectFailure(kernelPromise, done, 'No running kernel with id: ' + id);
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- describe('Kernel.shutdown()', () => {
|
|
|
-
|
|
|
- it('should shut down a kernel by id', (done) => {
|
|
|
- Kernel.shutdown('foo').then(done, done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle a 404 error', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(404, { });
|
|
|
- };
|
|
|
- Kernel.shutdown('foo').then(done, done);
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- describe('Kernel.IKernel', () => {
|
|
|
-
|
|
|
- beforeEach((done) => {
|
|
|
- Kernel.startNew().then(k => {
|
|
|
- kernel = k;
|
|
|
- return kernel.ready;
|
|
|
- }).then(() => {
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- context('#terminated', () => {
|
|
|
-
|
|
|
- it('should be emitted when the kernel is shut down', (done) => {
|
|
|
- kernel.terminated.connect((sender, args) => {
|
|
|
- expect(sender).to.be(kernel);
|
|
|
- expect(args).to.be(void 0);
|
|
|
- done();
|
|
|
- });
|
|
|
- kernel.shutdown();
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#statusChanged', () => {
|
|
|
-
|
|
|
- it('should be a signal following the Kernel status', (done) => {
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'busy') {
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- tester.sendStatus('busy');
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#iopubMessage', () => {
|
|
|
-
|
|
|
- it('should be emitted for an iopub message', (done) => {
|
|
|
- kernel.iopubMessage.connect((k, msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('status');
|
|
|
- done();
|
|
|
- });
|
|
|
- let msg = KernelMessage.createMessage({
|
|
|
- msgType: 'status',
|
|
|
- channel: 'iopub',
|
|
|
- session: kernel.clientId
|
|
|
- }) as KernelMessage.IStatusMsg;
|
|
|
- msg.content.execution_state = 'idle';
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- });
|
|
|
-
|
|
|
- it('should be emitted regardless of the sender', (done) => {
|
|
|
- kernel.iopubMessage.connect((k, msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('status');
|
|
|
- done();
|
|
|
- });
|
|
|
- let msg = KernelMessage.createMessage({
|
|
|
- msgType: 'status',
|
|
|
- channel: 'iopub',
|
|
|
- session: 'baz'
|
|
|
- }) as KernelMessage.IStatusMsg;
|
|
|
- msg.content.execution_state = 'idle';
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#unhandledMessage', () => {
|
|
|
-
|
|
|
- it('should be emitted for an unhandled message', (done) => {
|
|
|
- kernel.unhandledMessage.connect((k, msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('foo');
|
|
|
- done();
|
|
|
- });
|
|
|
- let msg = KernelMessage.createShellMessage({
|
|
|
- msgType: 'foo',
|
|
|
- channel: 'shell',
|
|
|
- session: kernel.clientId
|
|
|
- });
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- });
|
|
|
-
|
|
|
- it('should not be emitted for an iopub signal', () => {
|
|
|
- let called = false;
|
|
|
- kernel.unhandledMessage.connect((k, msg) => {
|
|
|
- called = true;
|
|
|
- });
|
|
|
- let msg = KernelMessage.createMessage({
|
|
|
- msgType: 'status',
|
|
|
- channel: 'iopub',
|
|
|
- session: kernel.clientId
|
|
|
- }) as KernelMessage.IStatusMsg;
|
|
|
- msg.content.execution_state = 'idle';
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- expect(called).to.be(false);
|
|
|
- });
|
|
|
-
|
|
|
- it('should not be emitted for a different client session', () => {
|
|
|
- let called = false;
|
|
|
- kernel.unhandledMessage.connect((k, msg) => {
|
|
|
- called = true;
|
|
|
- });
|
|
|
- let msg = KernelMessage.createShellMessage({
|
|
|
- msgType: 'foo',
|
|
|
- channel: 'shell',
|
|
|
- session: 'baz'
|
|
|
- });
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- expect(called).to.be(false);
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#id', () => {
|
|
|
-
|
|
|
- it('should be a string', () => {
|
|
|
- expect(typeof kernel.id).to.be('string');
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#name', () => {
|
|
|
-
|
|
|
- it('should be a string', () => {
|
|
|
- expect(typeof kernel.name).to.be('string');
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#model', () => {
|
|
|
-
|
|
|
- it('should be an IModel', () => {
|
|
|
- let model = kernel.model;
|
|
|
- expect(typeof model.name).to.be('string');
|
|
|
- expect(typeof model.id).to.be('string');
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#username', () => {
|
|
|
-
|
|
|
- it('should be a string', () => {
|
|
|
- expect(typeof kernel.username).to.be('string');
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#serverSettings', () => {
|
|
|
-
|
|
|
- it('should be the server settings', () => {
|
|
|
- expect(kernel.serverSettings.baseUrl).to.be(PageConfig.getBaseUrl());
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#clientId', () => {
|
|
|
-
|
|
|
- it('should be a string', () => {
|
|
|
- expect(typeof kernel.clientId).to.be('string');
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#status', () => {
|
|
|
-
|
|
|
- it('should get an idle status', (done) => {
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'idle') {
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- tester.sendStatus('idle');
|
|
|
- });
|
|
|
-
|
|
|
- it('should get a restarting status', (done) => {
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'restarting') {
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- tester.sendStatus('restarting');
|
|
|
- });
|
|
|
-
|
|
|
- it('should get a busy status', (done) => {
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'busy') {
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- tester.sendStatus('busy');
|
|
|
- });
|
|
|
-
|
|
|
- it('should get a reconnecting status', (done) => {
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'reconnecting') {
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- tester.close();
|
|
|
- });
|
|
|
-
|
|
|
- it('should get a dead status', (done) => {
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'dead') {
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- tester.sendStatus('dead');
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle an invalid status', (done) => {
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'idle') {
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- tester.sendStatus('celebrating');
|
|
|
- tester.sendStatus('idle');
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#info', () => {
|
|
|
-
|
|
|
- it('should get the kernel info', () => {
|
|
|
- return kernel.ready.then(() => {
|
|
|
- let name = kernel.info.language_info.name;
|
|
|
- expect(name).to.be(EXAMPLE_KERNEL_INFO.language_info.name);
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#getSpec()', () => {
|
|
|
-
|
|
|
- it('should resolve with the spec', () => {
|
|
|
- return kernel.getSpec().then(spec => {
|
|
|
- expect(spec.language).to.be('python');
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#isReady', () => {
|
|
|
-
|
|
|
- it('should test whether the kernel is ready', () => {
|
|
|
- return kernel.shutdown().then (() => {
|
|
|
- return Kernel.startNew();
|
|
|
- }).then(k => {
|
|
|
- kernel = k;
|
|
|
- expect(kernel.isReady).to.be(false);
|
|
|
- return kernel.ready;
|
|
|
- }).then(() => {
|
|
|
- expect(kernel.isReady).to.be(true);
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#ready', () => {
|
|
|
-
|
|
|
- it('should resolve when the kernel is ready', () => {
|
|
|
- return kernel.ready;
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#isDisposed', () => {
|
|
|
-
|
|
|
- it('should be true after we dispose of the kernel', () => {
|
|
|
- expect(kernel.isDisposed).to.be(false);
|
|
|
- kernel.dispose();
|
|
|
- expect(kernel.isDisposed).to.be(true);
|
|
|
- });
|
|
|
-
|
|
|
- it('should be safe to call multiple times', () => {
|
|
|
- expect(kernel.isDisposed).to.be(false);
|
|
|
- expect(kernel.isDisposed).to.be(false);
|
|
|
- kernel.dispose();
|
|
|
- expect(kernel.isDisposed).to.be(true);
|
|
|
- expect(kernel.isDisposed).to.be(true);
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#dispose()', () => {
|
|
|
-
|
|
|
- it('should dispose of the resources held by the kernel', () => {
|
|
|
- let future = kernel.requestExecute({ code: 'foo' });
|
|
|
- let comm = kernel.connectToComm('foo');
|
|
|
- expect(future.isDisposed).to.be(false);
|
|
|
- expect(comm.isDisposed).to.be(false);
|
|
|
- kernel.dispose();
|
|
|
- expect(future.isDisposed).to.be(true);
|
|
|
- expect(comm.isDisposed).to.be(true);
|
|
|
- });
|
|
|
-
|
|
|
- it('should be safe to call twice', () => {
|
|
|
- let future = kernel.requestExecute({ code: 'foo' });
|
|
|
- let comm = kernel.connectToComm('foo');
|
|
|
- expect(future.isDisposed).to.be(false);
|
|
|
- expect(comm.isDisposed).to.be(false);
|
|
|
- kernel.dispose();
|
|
|
- expect(future.isDisposed).to.be(true);
|
|
|
- expect(comm.isDisposed).to.be(true);
|
|
|
- expect(kernel.isDisposed).to.be(true);
|
|
|
- kernel.dispose();
|
|
|
- expect(future.isDisposed).to.be(true);
|
|
|
- expect(comm.isDisposed).to.be(true);
|
|
|
- expect(kernel.isDisposed).to.be(true);
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#sendShellMessage()', () => {
|
|
|
-
|
|
|
- it('should send a message to the kernel', (done) => {
|
|
|
- let options: KernelMessage.IOptions = {
|
|
|
- msgType: 'custom',
|
|
|
- channel: 'shell',
|
|
|
- username: kernel.username,
|
|
|
- session: kernel.clientId
|
|
|
- };
|
|
|
- let msg = KernelMessage.createShellMessage(options);
|
|
|
- kernel.sendShellMessage(msg, true);
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('custom');
|
|
|
- done();
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should send a binary message', (done) => {
|
|
|
- let options: KernelMessage.IOptions = {
|
|
|
- msgType: 'custom',
|
|
|
- channel: 'shell',
|
|
|
- username: kernel.username,
|
|
|
- session: kernel.clientId
|
|
|
- };
|
|
|
- let encoder = new TextEncoder('utf8');
|
|
|
- let data = encoder.encode('hello');
|
|
|
- let msg = KernelMessage.createShellMessage(options, {}, {}, [data, data.buffer]);
|
|
|
- kernel.sendShellMessage(msg, true);
|
|
|
-
|
|
|
- tester.onMessage((msg: any) => {
|
|
|
- let decoder = new TextDecoder('utf8');
|
|
|
- let item = msg.buffers[0] as DataView;
|
|
|
- expect(decoder.decode(item)).to.be('hello');
|
|
|
- done();
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should fail if the kernel is dead', (done) => {
|
|
|
- let options: KernelMessage.IOptions = {
|
|
|
- msgType: 'custom',
|
|
|
- channel: 'shell',
|
|
|
- username: kernel.username,
|
|
|
- session: kernel.clientId
|
|
|
- };
|
|
|
- let msg = KernelMessage.createShellMessage(options);
|
|
|
- tester.sendStatus('dead');
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- try {
|
|
|
- kernel.sendShellMessage(msg, true);
|
|
|
- } catch (err) {
|
|
|
- expect(err.message).to.be('Kernel is dead');
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle out of order messages', (done) => {
|
|
|
- let options: KernelMessage.IOptions = {
|
|
|
- msgType: 'custom',
|
|
|
- channel: 'shell',
|
|
|
- username: kernel.username,
|
|
|
- session: kernel.clientId
|
|
|
- };
|
|
|
- let msg = KernelMessage.createShellMessage(options);
|
|
|
- let future = kernel.sendShellMessage(msg, true);
|
|
|
- let newMsg: KernelMessage.IMessage;
|
|
|
-
|
|
|
- tester.onMessage((msg) => {
|
|
|
- // trigger onDone
|
|
|
- options.msgType = 'status';
|
|
|
- options.channel = 'iopub';
|
|
|
- newMsg = KernelMessage.createMessage(options, { execution_state: 'idle' });
|
|
|
- newMsg.parent_header = msg.header;
|
|
|
- tester.send(newMsg);
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- options.msgType = 'custom';
|
|
|
- options.channel = 'shell';
|
|
|
- newMsg = KernelMessage.createShellMessage(options);
|
|
|
- newMsg.parent_header = msg.header;
|
|
|
- tester.send(newMsg);
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- done();
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#interrupt()', () => {
|
|
|
-
|
|
|
- it('should interrupt and resolve with a valid server response', (done) => {
|
|
|
- kernel.interrupt().then(() => { done(); });
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an invalid response', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { id: kernel.id, name: kernel.name });
|
|
|
- };
|
|
|
- let interrupt = kernel.interrupt();
|
|
|
- expectAjaxError(interrupt, done, 'Invalid Status: 200');
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an error response', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(500, { });
|
|
|
- };
|
|
|
- let interrupt = kernel.interrupt();
|
|
|
- expectFailure(interrupt, done, '');
|
|
|
- });
|
|
|
-
|
|
|
- it('should fail if the kernel is dead', (done) => {
|
|
|
- tester.sendStatus('dead');
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'dead') {
|
|
|
- expectFailure(kernel.interrupt(), done, 'Kernel is dead');
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#restart()', () => {
|
|
|
-
|
|
|
- it('should restart and resolve with a valid server response', (done) => {
|
|
|
- kernel.restart().then(() => { done(); });
|
|
|
- });
|
|
|
-
|
|
|
- it('should fail if the kernel does not restart', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(500, {});
|
|
|
- };
|
|
|
- let restart = kernel.restart();
|
|
|
- expectFailure(restart, done, '');
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an invalid response', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(205, { id: kernel.id, name: kernel.name });
|
|
|
- };
|
|
|
- let restart = kernel.restart();
|
|
|
- expectAjaxError(restart, done, 'Invalid Status: 205');
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an error response', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(500, { });
|
|
|
- };
|
|
|
- let restart = kernel.restart();
|
|
|
- expectFailure(restart, done, '');
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an invalid id', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { });
|
|
|
- };
|
|
|
- let restart = kernel.restart();
|
|
|
- expectFailure(restart, done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should dispose of existing comm and future objects', (done) => {
|
|
|
- let comm = kernel.connectToComm('test');
|
|
|
- let future = kernel.requestExecute({ code: 'foo' });
|
|
|
- tester.runningKernels = [{ id: kernel.id, name: kernel.name }];
|
|
|
- kernel.restart().then(() => {
|
|
|
- expect(comm.isDisposed).to.be(true);
|
|
|
- expect(future.isDisposed).to.be(true);
|
|
|
- done();
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- describe('#reconnect()', () => {
|
|
|
-
|
|
|
- it('should reconnect the websocket', (done) => {
|
|
|
- kernel.ready.then(() => {
|
|
|
- return kernel.reconnect();
|
|
|
- }).then(() => {
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- it("should emit a `'reconnecting'` status", (done) => {
|
|
|
- let called = false;
|
|
|
- kernel.ready.then(() => {
|
|
|
- return kernel.reconnect();
|
|
|
- }).then(() => {
|
|
|
- expect(called).to.be(true);
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'reconnecting') {
|
|
|
- called = true;
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#shutdown()', () => {
|
|
|
-
|
|
|
- it('should shut down and resolve with a valid server response', (done) => {
|
|
|
- kernel.shutdown().then(() => { done(); });
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an invalid response', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { id: uuid(), name: KERNEL_OPTIONS.name });
|
|
|
- };
|
|
|
- let shutdown = kernel.shutdown();
|
|
|
- expectAjaxError(shutdown, done, 'Invalid Status: 200');
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle a 404 error', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(404, { });
|
|
|
- };
|
|
|
- kernel.shutdown().then(done, done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an error response', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(500, { });
|
|
|
- };
|
|
|
- let shutdown = kernel.shutdown();
|
|
|
- expectFailure(shutdown, done, '');
|
|
|
- });
|
|
|
-
|
|
|
- it('should fail if the kernel is dead', (done) => {
|
|
|
- tester.sendStatus('dead');
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'dead') {
|
|
|
- expectFailure(kernel.shutdown(), done, 'Kernel is dead');
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should dispose of all kernel instances', (done) => {
|
|
|
- let kernel2: Kernel.IKernel;
|
|
|
- Kernel.connectTo(kernel.id).then(k => {
|
|
|
- kernel2 = k;
|
|
|
- return kernel.shutdown();
|
|
|
- }).then(() => {
|
|
|
- expect(kernel2.isDisposed).to.be(true);
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#requestKernelInfo()', () => {
|
|
|
-
|
|
|
- it('should resolve the promise', (done) => {
|
|
|
- // resolved by KernelTester
|
|
|
- kernel.requestKernelInfo().then((msg) => {
|
|
|
- let name = msg.content.language_info.name;
|
|
|
- expect(name).to.be(EXAMPLE_KERNEL_INFO.language_info.name);
|
|
|
- done();
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#requestComplete()', () => {
|
|
|
-
|
|
|
- it('should resolve the promise', (done) => {
|
|
|
- let options: KernelMessage.ICompleteRequest = {
|
|
|
- code: 'hello',
|
|
|
- cursor_pos: 4
|
|
|
- };
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('complete_request');
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- });
|
|
|
- kernel.requestComplete(options).then(() => { done(); });
|
|
|
- });
|
|
|
-
|
|
|
- it('should reject the promise if the kernel is dead', (done) => {
|
|
|
- let options: KernelMessage.ICompleteRequest = {
|
|
|
- code: 'hello',
|
|
|
- cursor_pos: 4
|
|
|
- };
|
|
|
- tester.sendStatus('dead');
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- if (kernel.status === 'dead') {
|
|
|
- let promise = kernel.requestComplete(options);
|
|
|
- expectFailure(promise, done, 'Kernel is dead');
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#requestInspect()', () => {
|
|
|
-
|
|
|
- it('should resolve the promise', (done) => {
|
|
|
- let options: KernelMessage.IInspectRequest = {
|
|
|
- code: 'hello',
|
|
|
- cursor_pos: 4,
|
|
|
- detail_level: 0
|
|
|
- };
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('inspect_request');
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- });
|
|
|
- kernel.requestInspect(options).then(() => { done(); });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#requestIsComplete()', () => {
|
|
|
-
|
|
|
- it('should resolve the promise', (done) => {
|
|
|
- let options: KernelMessage.IIsCompleteRequest = {
|
|
|
- code: 'hello'
|
|
|
- };
|
|
|
- let promise = kernel.requestIsComplete(options);
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('is_complete_request');
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- });
|
|
|
- promise.then(() => { done(); });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#requestHistory()', () => {
|
|
|
-
|
|
|
- it('should resolve the promise', (done) => {
|
|
|
- let options: KernelMessage.IHistoryRequest = {
|
|
|
- output: true,
|
|
|
- raw: true,
|
|
|
- hist_access_type: 'search',
|
|
|
- session: 0,
|
|
|
- start: 1,
|
|
|
- stop: 2,
|
|
|
- n: 1,
|
|
|
- pattern: '*',
|
|
|
- unique: true,
|
|
|
- };
|
|
|
- let promise = kernel.requestHistory(options);
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('history_request');
|
|
|
- msg.parent_header = msg.header;
|
|
|
- tester.send(msg);
|
|
|
- });
|
|
|
- promise.then(() => { done(); });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#sendInputReply()', () => {
|
|
|
-
|
|
|
- it('should resolve the promise', (done) => {
|
|
|
- kernel.sendInputReply({ value: 'test' });
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.header.msg_type).to.be('input_reply');
|
|
|
- done();
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should fail if the kernel is dead', (done) => {
|
|
|
- tester.sendStatus('dead');
|
|
|
- kernel.statusChanged.connect(() => {
|
|
|
- try {
|
|
|
- kernel.sendInputReply({ value: 'test' });
|
|
|
- } catch (err) {
|
|
|
- expect(err.message).to.be('Kernel is dead');
|
|
|
- done();
|
|
|
- }
|
|
|
- });
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- context('#requestExecute()', () => {
|
|
|
-
|
|
|
- it('should send and handle incoming messages', (done) => {
|
|
|
- let newMsg: KernelMessage.IMessage;
|
|
|
- let content: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(content);
|
|
|
- expect(future.onDone).to.be(null);
|
|
|
- expect(future.onStdin).to.be(null);
|
|
|
- expect(future.onReply).to.be(null);
|
|
|
- expect(future.onIOPub).to.be(null);
|
|
|
-
|
|
|
- let options: KernelMessage.IOptions = {
|
|
|
- msgType: 'custom',
|
|
|
- channel: 'shell',
|
|
|
- username: kernel.username,
|
|
|
- session: kernel.clientId
|
|
|
- };
|
|
|
-
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.channel).to.be('shell');
|
|
|
-
|
|
|
- // send a reply
|
|
|
- options.channel = 'shell';
|
|
|
- newMsg = KernelMessage.createMessage(options);
|
|
|
- newMsg.parent_header = msg.header;
|
|
|
- tester.send(newMsg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onStdin
|
|
|
- options.channel = 'stdin';
|
|
|
- newMsg = KernelMessage.createMessage(options);
|
|
|
- newMsg.parent_header = msg.header;
|
|
|
- tester.send(newMsg);
|
|
|
- };
|
|
|
-
|
|
|
- future.onStdin = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- options.channel = 'iopub';
|
|
|
- options.msgType = 'stream';
|
|
|
- let streamContent: JSONObject = { name: 'stdout', text: '' };
|
|
|
- newMsg = KernelMessage.createMessage(options, streamContent);
|
|
|
- newMsg.parent_header = msg.header;
|
|
|
- tester.send(newMsg);
|
|
|
- };
|
|
|
-
|
|
|
- future.onIOPub = (ioMsg) => {
|
|
|
- if (ioMsg.header.msg_type === 'stream') {
|
|
|
- // trigger onDone
|
|
|
- options.msgType = 'status';
|
|
|
- newMsg = KernelMessage.createMessage(options, { execution_state: 'idle' });
|
|
|
- newMsg.parent_header = msg.header;
|
|
|
- tester.send(newMsg);
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- doLater(() => {
|
|
|
- expect(future.isDisposed).to.be(true);
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- it('should not dispose of KernelFuture when disposeOnDone=false', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- expect(future.onDone).to.be(null);
|
|
|
- expect(future.onStdin).to.be(null);
|
|
|
- expect(future.onReply).to.be(null);
|
|
|
- expect(future.onIOPub).to.be(null);
|
|
|
-
|
|
|
- tester.onMessage((msg) => {
|
|
|
- expect(msg.channel).to.be('shell');
|
|
|
-
|
|
|
- // send a reply
|
|
|
- msg.parent_header = msg.header;
|
|
|
- msg.channel = 'shell';
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- msg.channel = 'iopub';
|
|
|
- msg.header.msg_type = 'stream';
|
|
|
- msg.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msg);
|
|
|
- };
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- if (msg.header.msg_type === 'stream') {
|
|
|
- // trigger onDone
|
|
|
- msg.header.msg_type = 'status';
|
|
|
- (msg as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msg);
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- doLater(() => {
|
|
|
- expect(future.isDisposed).to.be(false);
|
|
|
- expect(future.onDone).to.be(null);
|
|
|
- expect(future.onIOPub).to.not.be(null);
|
|
|
- future.dispose();
|
|
|
- expect(future.onIOPub).to.be(null);
|
|
|
- expect(future.isDisposed).to.be(true);
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
-
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- context('#registerMessageHook()', () => {
|
|
|
-
|
|
|
- it('should have the most recently registered hook run first', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
- calls.push('last');
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
- calls.push('first');
|
|
|
- // not returning should also continue handling
|
|
|
- return void 0;
|
|
|
- });
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- // the last hook was called for the stream and the status message.
|
|
|
- expect(calls).to.eql(['first', 'last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
- doLater(() => {
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should abort processing if a hook returns false, but the done logic should still work', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
- calls.push('last');
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
- calls.push('first');
|
|
|
- return false;
|
|
|
- });
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- // the last hook was called for the stream and the status message.
|
|
|
- expect(calls).to.eql(['first', 'first']);
|
|
|
- doLater(() => {
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should process additions on the next run', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
- calls.push('last');
|
|
|
- kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
- calls.push('first');
|
|
|
- return true;
|
|
|
- });
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- expect(calls).to.eql(['last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
- doLater(() => {
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should deactivate a hook immediately on removal', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- let toDelete = (msg: KernelMessage.IIOPubMessage) => {
|
|
|
- calls.push('delete');
|
|
|
- return true;
|
|
|
- }
|
|
|
- let toDeleteHook = kernel.registerMessageHook(parent_header.msg_id, toDelete);
|
|
|
-
|
|
|
- kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
- if (calls.length > 0) {
|
|
|
- // delete the hook the second time around
|
|
|
- toDeleteHook.dispose();
|
|
|
- }
|
|
|
- calls.push('first');
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- expect(calls).to.eql(['first', 'delete', 'iopub', 'first', 'iopub']);
|
|
|
- doLater(() => {
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- describe('IFuture', () => {
|
|
|
-
|
|
|
- beforeEach((done) => {
|
|
|
- Kernel.startNew().then(k => {
|
|
|
- kernel = k;
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should have a msg attribute', () => {
|
|
|
- let future = kernel.requestExecute({ code: 'hello' });
|
|
|
- expect(typeof future.msg.header.msg_id).to.be('string');
|
|
|
- });
|
|
|
-
|
|
|
- describe('Message hooks', () => {
|
|
|
-
|
|
|
- it('should have the most recently registered hook run first', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- future.registerMessageHook((msg) => {
|
|
|
- calls.push('last');
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- future.registerMessageHook((msg) => {
|
|
|
- calls.push('first');
|
|
|
- // Check to make sure we actually got the messages we expected.
|
|
|
- if (msg.header.msg_type === 'stream') {
|
|
|
- expect((msg as KernelMessage.IStreamMsg).content.text).to.be('foo1');
|
|
|
- } else {
|
|
|
- expect((msg as KernelMessage.IStatusMsg).content.execution_state).to.be('idle');
|
|
|
- }
|
|
|
- // not returning should also continue handling
|
|
|
- return void 0;
|
|
|
- });
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- // the last hook was called for the stream and the status message.
|
|
|
- expect(calls).to.eql(['first', 'last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
- doLater(() => {
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should abort processing if a hook returns false, but the done logic should still work', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- future.registerMessageHook((msg) => {
|
|
|
- calls.push('last');
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- future.registerMessageHook((msg) => {
|
|
|
- calls.push('first');
|
|
|
- return false;
|
|
|
- });
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- // the last hook was called for the stream and the status message.
|
|
|
- expect(calls).to.eql(['first', 'first']);
|
|
|
- doLater(() => {
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should process additions on the next run', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- future.registerMessageHook((msg) => {
|
|
|
- calls.push('last');
|
|
|
- future.registerMessageHook((msg) => {
|
|
|
- calls.push('first');
|
|
|
- return true;
|
|
|
- });
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- expect(calls).to.eql(['last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
- doLater(() => {
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- it('should deactivate message hooks immediately on removal', (done) => {
|
|
|
- let options: KernelMessage.IExecuteRequest = {
|
|
|
- code: 'test',
|
|
|
- silent: false,
|
|
|
- store_history: true,
|
|
|
- user_expressions: {},
|
|
|
- allow_stdin: false,
|
|
|
- stop_on_error: false
|
|
|
- };
|
|
|
- let future = kernel.requestExecute(options, false);
|
|
|
- tester.onMessage((message) => {
|
|
|
- // send a reply
|
|
|
- let parent_header = message.header;
|
|
|
- let msg = createMsg('shell', parent_header);
|
|
|
- tester.send(msg);
|
|
|
-
|
|
|
- future.onReply = () => {
|
|
|
- // trigger onIOPub with a 'stream' message
|
|
|
- let msgStream = createMsg('iopub', parent_header);
|
|
|
- msgStream.header.msg_type = 'stream';
|
|
|
- msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
- tester.send(msgStream);
|
|
|
- // trigger onDone
|
|
|
- let msgDone = createMsg('iopub', parent_header);
|
|
|
- msgDone.header.msg_type = 'status';
|
|
|
- (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
- tester.send(msgDone);
|
|
|
- };
|
|
|
-
|
|
|
- let calls: string[] = [];
|
|
|
- let toDelete = (msg: KernelMessage.IIOPubMessage) => {
|
|
|
- calls.push('delete');
|
|
|
- return true;
|
|
|
- }
|
|
|
- future.registerMessageHook(toDelete);
|
|
|
-
|
|
|
- let first = (msg: KernelMessage.IIOPubMessage) => {
|
|
|
- if (calls.length > 0) {
|
|
|
- // delete the hook the second time around
|
|
|
- future.removeMessageHook(toDelete);
|
|
|
- }
|
|
|
- calls.push('first');
|
|
|
- return true;
|
|
|
- }
|
|
|
- future.registerMessageHook(first);
|
|
|
-
|
|
|
- future.onIOPub = () => {
|
|
|
- calls.push('iopub')
|
|
|
- };
|
|
|
-
|
|
|
- future.onDone = () => {
|
|
|
- expect(calls).to.eql(['first', 'delete', 'iopub', 'first', 'iopub']);
|
|
|
- doLater(() => {
|
|
|
- future.dispose();
|
|
|
- future.removeMessageHook(first);
|
|
|
- done();
|
|
|
- });
|
|
|
- };
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
- });
|
|
|
-
|
|
|
- describe('Kernel.getSpecs()', () => {
|
|
|
-
|
|
|
- it('should load the kernelspecs', (done) => {
|
|
|
- let ids = {
|
|
|
- 'python': PYTHON_SPEC,
|
|
|
- 'python3': PYTHON3_SPEC
|
|
|
- };
|
|
|
- tester.specs = { 'default': 'python',
|
|
|
- 'kernelspecs': ids };
|
|
|
- Kernel.getSpecs().then(specs => {
|
|
|
- let names = Object.keys(specs.kernelspecs);
|
|
|
- expect(names[0]).to.be('python');
|
|
|
- expect(names[1]).to.be('python3');
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should accept ajax options', (done) => {
|
|
|
- let ids = {
|
|
|
- 'python': PYTHON_SPEC,
|
|
|
- 'python3': PYTHON3_SPEC
|
|
|
- };
|
|
|
- tester.specs = { 'default': 'python',
|
|
|
- 'kernelspecs': ids };
|
|
|
- Kernel.getSpecs(serverSettings).then(specs => {
|
|
|
- let names = Object.keys(specs.kernelspecs);
|
|
|
- expect(names[0]).to.be('python');
|
|
|
- expect(names[1]).to.be('python3');
|
|
|
- done();
|
|
|
- }).catch(done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle a missing default parameter', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'kernelspecs': { 'python': PYTHON_SPEC } });
|
|
|
- };
|
|
|
- Kernel.getSpecs().then(specs => {
|
|
|
- expect(specs.default).to.be('python');
|
|
|
- }).then(done, done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw for a missing kernelspecs parameter', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'default': PYTHON_SPEC.name });
|
|
|
- };
|
|
|
- let promise = Kernel.getSpecs();
|
|
|
- expectAjaxError(promise, done, 'No kernelspecs found');
|
|
|
- });
|
|
|
-
|
|
|
- it('should omit an invalid kernelspec', (done) => {
|
|
|
- let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
- R_SPEC.name = 1;
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'default': 'python',
|
|
|
- 'kernelspecs': { 'R': R_SPEC,
|
|
|
- 'python': PYTHON_SPEC }
|
|
|
- });
|
|
|
- };
|
|
|
- Kernel.getSpecs().then(specs => {
|
|
|
- expect(specs.default).to.be('python');
|
|
|
- expect(specs.kernelspecs['R']).to.be(void 0);
|
|
|
- }).then(done, done);
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle an improper name', (done) => {
|
|
|
- let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
- R_SPEC.name = 1;
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'default': 'R',
|
|
|
- 'kernelspecs': { 'R': R_SPEC } });
|
|
|
- };
|
|
|
- let promise = Kernel.getSpecs();
|
|
|
- expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle an improper language', (done) => {
|
|
|
- let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
- R_SPEC.spec.language = 1;
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'default': 'R',
|
|
|
- 'kernelspecs': { 'R': R_SPEC } });
|
|
|
- };
|
|
|
- let promise = Kernel.getSpecs();
|
|
|
- expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle an improper argv', (done) => {
|
|
|
- let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
- R_SPEC.spec.argv = 'hello';
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'default': 'R',
|
|
|
- 'kernelspecs': { 'R': R_SPEC } });
|
|
|
- };
|
|
|
- let promise = Kernel.getSpecs();
|
|
|
- expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle an improper display_name', (done) => {
|
|
|
- let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
- R_SPEC.spec.display_name = ['hello'];
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'default': 'R',
|
|
|
- 'kernelspecs': { 'R': R_SPEC } });
|
|
|
- };
|
|
|
- let promise = Kernel.getSpecs();
|
|
|
- expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
- });
|
|
|
-
|
|
|
- it('should handle missing resources', (done) => {
|
|
|
- let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
- delete R_SPEC.resources;
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(200, { 'default': 'R',
|
|
|
- 'kernelspecs': { 'R': R_SPEC } });
|
|
|
- };
|
|
|
- let promise = Kernel.getSpecs();
|
|
|
- expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
- });
|
|
|
-
|
|
|
- it('should throw an error for an invalid response', (done) => {
|
|
|
- tester.onRequest = () => {
|
|
|
- tester.respond(201, { });
|
|
|
- };
|
|
|
- let promise = Kernel.getSpecs();
|
|
|
- expectAjaxError(promise, done, 'Invalid Status: 201');
|
|
|
- });
|
|
|
-
|
|
|
- });
|
|
|
+ // describe('Kernel.connectTo()', () => {
|
|
|
+
|
|
|
+ // it('should reuse an exisiting kernel', (done) => {
|
|
|
+ // let id = uuid();
|
|
|
+ // tester.runningKernels = [{ name: 'foo', id }];
|
|
|
+ // Kernel.connectTo(id).then(k => {
|
|
|
+ // kernel = k;
|
|
|
+ // Kernel.connectTo(id).then(newKernel => {
|
|
|
+ // expect(newKernel.name).to.be(kernel.name);
|
|
|
+ // expect(newKernel.id).to.be(kernel.id);
|
|
|
+ // newKernel.dispose();
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should connect to a running kernel if given kernel options', (done) => {
|
|
|
+ // let id = uuid();
|
|
|
+ // tester.runningKernels = [{ name: KERNEL_OPTIONS.name, id }];
|
|
|
+ // Kernel.connectTo(id).then(k => {
|
|
|
+ // kernel = k;
|
|
|
+ // expect(kernel.name).to.be(KERNEL_OPTIONS.name);
|
|
|
+ // expect(kernel.id).to.be(id);
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should accept server settings', (done) => {
|
|
|
+ // let id = uuid();
|
|
|
+ // tester.runningKernels = [{ name: KERNEL_OPTIONS.name, id }];
|
|
|
+ // Kernel.connectTo(id, serverSettings).then(k => {
|
|
|
+ // kernel = k;
|
|
|
+ // expect(kernel.name).to.be(KERNEL_OPTIONS.name);
|
|
|
+ // expect(kernel.id).to.be(id);
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should fail if no running kernel available', (done) => {
|
|
|
+ // let id = uuid();
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(400, { });
|
|
|
+ // };
|
|
|
+ // let kernelPromise = Kernel.connectTo(id);
|
|
|
+ // expectFailure(kernelPromise, done, 'No running kernel with id: ' + id);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // describe('Kernel.shutdown()', () => {
|
|
|
+
|
|
|
+ // it('should shut down a kernel by id', (done) => {
|
|
|
+ // Kernel.shutdown('foo').then(done, done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle a 404 error', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(404, { });
|
|
|
+ // };
|
|
|
+ // Kernel.shutdown('foo').then(done, done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // describe('Kernel.IKernel', () => {
|
|
|
+
|
|
|
+ // beforeEach((done) => {
|
|
|
+ // Kernel.startNew().then(k => {
|
|
|
+ // kernel = k;
|
|
|
+ // return kernel.ready;
|
|
|
+ // }).then(() => {
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#terminated', () => {
|
|
|
+
|
|
|
+ // it('should be emitted when the kernel is shut down', (done) => {
|
|
|
+ // kernel.terminated.connect((sender, args) => {
|
|
|
+ // expect(sender).to.be(kernel);
|
|
|
+ // expect(args).to.be(void 0);
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // kernel.shutdown();
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#statusChanged', () => {
|
|
|
+
|
|
|
+ // it('should be a signal following the Kernel status', (done) => {
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'busy') {
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // tester.sendStatus('busy');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#iopubMessage', () => {
|
|
|
+
|
|
|
+ // it('should be emitted for an iopub message', (done) => {
|
|
|
+ // kernel.iopubMessage.connect((k, msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('status');
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // let msg = KernelMessage.createMessage({
|
|
|
+ // msgType: 'status',
|
|
|
+ // channel: 'iopub',
|
|
|
+ // session: kernel.clientId
|
|
|
+ // }) as KernelMessage.IStatusMsg;
|
|
|
+ // msg.content.execution_state = 'idle';
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should be emitted regardless of the sender', (done) => {
|
|
|
+ // kernel.iopubMessage.connect((k, msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('status');
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // let msg = KernelMessage.createMessage({
|
|
|
+ // msgType: 'status',
|
|
|
+ // channel: 'iopub',
|
|
|
+ // session: 'baz'
|
|
|
+ // }) as KernelMessage.IStatusMsg;
|
|
|
+ // msg.content.execution_state = 'idle';
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#unhandledMessage', () => {
|
|
|
+
|
|
|
+ // it('should be emitted for an unhandled message', (done) => {
|
|
|
+ // kernel.unhandledMessage.connect((k, msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('foo');
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // let msg = KernelMessage.createShellMessage({
|
|
|
+ // msgType: 'foo',
|
|
|
+ // channel: 'shell',
|
|
|
+ // session: kernel.clientId
|
|
|
+ // });
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should not be emitted for an iopub signal', () => {
|
|
|
+ // let called = false;
|
|
|
+ // kernel.unhandledMessage.connect((k, msg) => {
|
|
|
+ // called = true;
|
|
|
+ // });
|
|
|
+ // let msg = KernelMessage.createMessage({
|
|
|
+ // msgType: 'status',
|
|
|
+ // channel: 'iopub',
|
|
|
+ // session: kernel.clientId
|
|
|
+ // }) as KernelMessage.IStatusMsg;
|
|
|
+ // msg.content.execution_state = 'idle';
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // expect(called).to.be(false);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should not be emitted for a different client session', () => {
|
|
|
+ // let called = false;
|
|
|
+ // kernel.unhandledMessage.connect((k, msg) => {
|
|
|
+ // called = true;
|
|
|
+ // });
|
|
|
+ // let msg = KernelMessage.createShellMessage({
|
|
|
+ // msgType: 'foo',
|
|
|
+ // channel: 'shell',
|
|
|
+ // session: 'baz'
|
|
|
+ // });
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // expect(called).to.be(false);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#id', () => {
|
|
|
+
|
|
|
+ // it('should be a string', () => {
|
|
|
+ // expect(typeof kernel.id).to.be('string');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#name', () => {
|
|
|
+
|
|
|
+ // it('should be a string', () => {
|
|
|
+ // expect(typeof kernel.name).to.be('string');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#model', () => {
|
|
|
+
|
|
|
+ // it('should be an IModel', () => {
|
|
|
+ // let model = kernel.model;
|
|
|
+ // expect(typeof model.name).to.be('string');
|
|
|
+ // expect(typeof model.id).to.be('string');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#username', () => {
|
|
|
+
|
|
|
+ // it('should be a string', () => {
|
|
|
+ // expect(typeof kernel.username).to.be('string');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#serverSettings', () => {
|
|
|
+
|
|
|
+ // it('should be the server settings', () => {
|
|
|
+ // expect(kernel.serverSettings.baseUrl).to.be(PageConfig.getBaseUrl());
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#clientId', () => {
|
|
|
+
|
|
|
+ // it('should be a string', () => {
|
|
|
+ // expect(typeof kernel.clientId).to.be('string');
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#status', () => {
|
|
|
+
|
|
|
+ // it('should get an idle status', (done) => {
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'idle') {
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // tester.sendStatus('idle');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should get a restarting status', (done) => {
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'restarting') {
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // tester.sendStatus('restarting');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should get a busy status', (done) => {
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'busy') {
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // tester.sendStatus('busy');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should get a reconnecting status', (done) => {
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'reconnecting') {
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // tester.close();
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should get a dead status', (done) => {
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'dead') {
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // tester.sendStatus('dead');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle an invalid status', (done) => {
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'idle') {
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // tester.sendStatus('celebrating');
|
|
|
+ // tester.sendStatus('idle');
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#info', () => {
|
|
|
+
|
|
|
+ // it('should get the kernel info', () => {
|
|
|
+ // return kernel.ready.then(() => {
|
|
|
+ // let name = kernel.info.language_info.name;
|
|
|
+ // expect(name).to.be(EXAMPLE_KERNEL_INFO.language_info.name);
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#getSpec()', () => {
|
|
|
+
|
|
|
+ // it('should resolve with the spec', () => {
|
|
|
+ // return kernel.getSpec().then(spec => {
|
|
|
+ // expect(spec.language).to.be('python');
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#isReady', () => {
|
|
|
+
|
|
|
+ // it('should test whether the kernel is ready', () => {
|
|
|
+ // return kernel.shutdown().then (() => {
|
|
|
+ // return Kernel.startNew();
|
|
|
+ // }).then(k => {
|
|
|
+ // kernel = k;
|
|
|
+ // expect(kernel.isReady).to.be(false);
|
|
|
+ // return kernel.ready;
|
|
|
+ // }).then(() => {
|
|
|
+ // expect(kernel.isReady).to.be(true);
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#ready', () => {
|
|
|
+
|
|
|
+ // it('should resolve when the kernel is ready', () => {
|
|
|
+ // return kernel.ready;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#isDisposed', () => {
|
|
|
+
|
|
|
+ // it('should be true after we dispose of the kernel', () => {
|
|
|
+ // expect(kernel.isDisposed).to.be(false);
|
|
|
+ // kernel.dispose();
|
|
|
+ // expect(kernel.isDisposed).to.be(true);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should be safe to call multiple times', () => {
|
|
|
+ // expect(kernel.isDisposed).to.be(false);
|
|
|
+ // expect(kernel.isDisposed).to.be(false);
|
|
|
+ // kernel.dispose();
|
|
|
+ // expect(kernel.isDisposed).to.be(true);
|
|
|
+ // expect(kernel.isDisposed).to.be(true);
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#dispose()', () => {
|
|
|
+
|
|
|
+ // it('should dispose of the resources held by the kernel', () => {
|
|
|
+ // let future = kernel.requestExecute({ code: 'foo' });
|
|
|
+ // let comm = kernel.connectToComm('foo');
|
|
|
+ // expect(future.isDisposed).to.be(false);
|
|
|
+ // expect(comm.isDisposed).to.be(false);
|
|
|
+ // kernel.dispose();
|
|
|
+ // expect(future.isDisposed).to.be(true);
|
|
|
+ // expect(comm.isDisposed).to.be(true);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should be safe to call twice', () => {
|
|
|
+ // let future = kernel.requestExecute({ code: 'foo' });
|
|
|
+ // let comm = kernel.connectToComm('foo');
|
|
|
+ // expect(future.isDisposed).to.be(false);
|
|
|
+ // expect(comm.isDisposed).to.be(false);
|
|
|
+ // kernel.dispose();
|
|
|
+ // expect(future.isDisposed).to.be(true);
|
|
|
+ // expect(comm.isDisposed).to.be(true);
|
|
|
+ // expect(kernel.isDisposed).to.be(true);
|
|
|
+ // kernel.dispose();
|
|
|
+ // expect(future.isDisposed).to.be(true);
|
|
|
+ // expect(comm.isDisposed).to.be(true);
|
|
|
+ // expect(kernel.isDisposed).to.be(true);
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#sendShellMessage()', () => {
|
|
|
+
|
|
|
+ // it('should send a message to the kernel', (done) => {
|
|
|
+ // let options: KernelMessage.IOptions = {
|
|
|
+ // msgType: 'custom',
|
|
|
+ // channel: 'shell',
|
|
|
+ // username: kernel.username,
|
|
|
+ // session: kernel.clientId
|
|
|
+ // };
|
|
|
+ // let msg = KernelMessage.createShellMessage(options);
|
|
|
+ // kernel.sendShellMessage(msg, true);
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('custom');
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should send a binary message', (done) => {
|
|
|
+ // let options: KernelMessage.IOptions = {
|
|
|
+ // msgType: 'custom',
|
|
|
+ // channel: 'shell',
|
|
|
+ // username: kernel.username,
|
|
|
+ // session: kernel.clientId
|
|
|
+ // };
|
|
|
+ // let encoder = new TextEncoder('utf8');
|
|
|
+ // let data = encoder.encode('hello');
|
|
|
+ // let msg = KernelMessage.createShellMessage(options, {}, {}, [data, data.buffer]);
|
|
|
+ // kernel.sendShellMessage(msg, true);
|
|
|
+
|
|
|
+ // tester.onMessage((msg: any) => {
|
|
|
+ // let decoder = new TextDecoder('utf8');
|
|
|
+ // let item = msg.buffers[0] as DataView;
|
|
|
+ // expect(decoder.decode(item)).to.be('hello');
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should fail if the kernel is dead', (done) => {
|
|
|
+ // let options: KernelMessage.IOptions = {
|
|
|
+ // msgType: 'custom',
|
|
|
+ // channel: 'shell',
|
|
|
+ // username: kernel.username,
|
|
|
+ // session: kernel.clientId
|
|
|
+ // };
|
|
|
+ // let msg = KernelMessage.createShellMessage(options);
|
|
|
+ // tester.sendStatus('dead');
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // try {
|
|
|
+ // kernel.sendShellMessage(msg, true);
|
|
|
+ // } catch (err) {
|
|
|
+ // expect(err.message).to.be('Kernel is dead');
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle out of order messages', (done) => {
|
|
|
+ // let options: KernelMessage.IOptions = {
|
|
|
+ // msgType: 'custom',
|
|
|
+ // channel: 'shell',
|
|
|
+ // username: kernel.username,
|
|
|
+ // session: kernel.clientId
|
|
|
+ // };
|
|
|
+ // let msg = KernelMessage.createShellMessage(options);
|
|
|
+ // let future = kernel.sendShellMessage(msg, true);
|
|
|
+ // let newMsg: KernelMessage.IMessage;
|
|
|
+
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // // trigger onDone
|
|
|
+ // options.msgType = 'status';
|
|
|
+ // options.channel = 'iopub';
|
|
|
+ // newMsg = KernelMessage.createMessage(options, { execution_state: 'idle' });
|
|
|
+ // newMsg.parent_header = msg.header;
|
|
|
+ // tester.send(newMsg);
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // options.msgType = 'custom';
|
|
|
+ // options.channel = 'shell';
|
|
|
+ // newMsg = KernelMessage.createShellMessage(options);
|
|
|
+ // newMsg.parent_header = msg.header;
|
|
|
+ // tester.send(newMsg);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // done();
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#interrupt()', () => {
|
|
|
+
|
|
|
+ // it('should interrupt and resolve with a valid server response', (done) => {
|
|
|
+ // kernel.interrupt().then(() => { done(); });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an invalid response', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { id: kernel.id, name: kernel.name });
|
|
|
+ // };
|
|
|
+ // let interrupt = kernel.interrupt();
|
|
|
+ // expectAjaxError(interrupt, done, 'Invalid Status: 200');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an error response', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(500, { });
|
|
|
+ // };
|
|
|
+ // let interrupt = kernel.interrupt();
|
|
|
+ // expectFailure(interrupt, done, '');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should fail if the kernel is dead', (done) => {
|
|
|
+ // tester.sendStatus('dead');
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'dead') {
|
|
|
+ // expectFailure(kernel.interrupt(), done, 'Kernel is dead');
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#restart()', () => {
|
|
|
+
|
|
|
+ // it('should restart and resolve with a valid server response', (done) => {
|
|
|
+ // kernel.restart().then(() => { done(); });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should fail if the kernel does not restart', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(500, {});
|
|
|
+ // };
|
|
|
+ // let restart = kernel.restart();
|
|
|
+ // expectFailure(restart, done, '');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an invalid response', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(205, { id: kernel.id, name: kernel.name });
|
|
|
+ // };
|
|
|
+ // let restart = kernel.restart();
|
|
|
+ // expectAjaxError(restart, done, 'Invalid Status: 205');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an error response', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(500, { });
|
|
|
+ // };
|
|
|
+ // let restart = kernel.restart();
|
|
|
+ // expectFailure(restart, done, '');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an invalid id', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { });
|
|
|
+ // };
|
|
|
+ // let restart = kernel.restart();
|
|
|
+ // expectFailure(restart, done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should dispose of existing comm and future objects', (done) => {
|
|
|
+ // let comm = kernel.connectToComm('test');
|
|
|
+ // let future = kernel.requestExecute({ code: 'foo' });
|
|
|
+ // tester.runningKernels = [{ id: kernel.id, name: kernel.name }];
|
|
|
+ // kernel.restart().then(() => {
|
|
|
+ // expect(comm.isDisposed).to.be(true);
|
|
|
+ // expect(future.isDisposed).to.be(true);
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // describe('#reconnect()', () => {
|
|
|
+
|
|
|
+ // it('should reconnect the websocket', (done) => {
|
|
|
+ // kernel.ready.then(() => {
|
|
|
+ // return kernel.reconnect();
|
|
|
+ // }).then(() => {
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it("should emit a `'reconnecting'` status", (done) => {
|
|
|
+ // let called = false;
|
|
|
+ // kernel.ready.then(() => {
|
|
|
+ // return kernel.reconnect();
|
|
|
+ // }).then(() => {
|
|
|
+ // expect(called).to.be(true);
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'reconnecting') {
|
|
|
+ // called = true;
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#shutdown()', () => {
|
|
|
+
|
|
|
+ // it('should shut down and resolve with a valid server response', (done) => {
|
|
|
+ // kernel.shutdown().then(() => { done(); });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an invalid response', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { id: uuid(), name: KERNEL_OPTIONS.name });
|
|
|
+ // };
|
|
|
+ // let shutdown = kernel.shutdown();
|
|
|
+ // expectAjaxError(shutdown, done, 'Invalid Status: 200');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle a 404 error', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(404, { });
|
|
|
+ // };
|
|
|
+ // kernel.shutdown().then(done, done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an error response', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(500, { });
|
|
|
+ // };
|
|
|
+ // let shutdown = kernel.shutdown();
|
|
|
+ // expectFailure(shutdown, done, '');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should fail if the kernel is dead', (done) => {
|
|
|
+ // tester.sendStatus('dead');
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'dead') {
|
|
|
+ // expectFailure(kernel.shutdown(), done, 'Kernel is dead');
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should dispose of all kernel instances', (done) => {
|
|
|
+ // let kernel2: Kernel.IKernel;
|
|
|
+ // Kernel.connectTo(kernel.id).then(k => {
|
|
|
+ // kernel2 = k;
|
|
|
+ // return kernel.shutdown();
|
|
|
+ // }).then(() => {
|
|
|
+ // expect(kernel2.isDisposed).to.be(true);
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#requestKernelInfo()', () => {
|
|
|
+
|
|
|
+ // it('should resolve the promise', (done) => {
|
|
|
+ // // resolved by KernelTester
|
|
|
+ // kernel.requestKernelInfo().then((msg) => {
|
|
|
+ // let name = msg.content.language_info.name;
|
|
|
+ // expect(name).to.be(EXAMPLE_KERNEL_INFO.language_info.name);
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#requestComplete()', () => {
|
|
|
+
|
|
|
+ // it('should resolve the promise', (done) => {
|
|
|
+ // let options: KernelMessage.ICompleteRequest = {
|
|
|
+ // code: 'hello',
|
|
|
+ // cursor_pos: 4
|
|
|
+ // };
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('complete_request');
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // });
|
|
|
+ // kernel.requestComplete(options).then(() => { done(); });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should reject the promise if the kernel is dead', (done) => {
|
|
|
+ // let options: KernelMessage.ICompleteRequest = {
|
|
|
+ // code: 'hello',
|
|
|
+ // cursor_pos: 4
|
|
|
+ // };
|
|
|
+ // tester.sendStatus('dead');
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // if (kernel.status === 'dead') {
|
|
|
+ // let promise = kernel.requestComplete(options);
|
|
|
+ // expectFailure(promise, done, 'Kernel is dead');
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#requestInspect()', () => {
|
|
|
+
|
|
|
+ // it('should resolve the promise', (done) => {
|
|
|
+ // let options: KernelMessage.IInspectRequest = {
|
|
|
+ // code: 'hello',
|
|
|
+ // cursor_pos: 4,
|
|
|
+ // detail_level: 0
|
|
|
+ // };
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('inspect_request');
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // });
|
|
|
+ // kernel.requestInspect(options).then(() => { done(); });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#requestIsComplete()', () => {
|
|
|
+
|
|
|
+ // it('should resolve the promise', (done) => {
|
|
|
+ // let options: KernelMessage.IIsCompleteRequest = {
|
|
|
+ // code: 'hello'
|
|
|
+ // };
|
|
|
+ // let promise = kernel.requestIsComplete(options);
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('is_complete_request');
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // });
|
|
|
+ // promise.then(() => { done(); });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#requestHistory()', () => {
|
|
|
+
|
|
|
+ // it('should resolve the promise', (done) => {
|
|
|
+ // let options: KernelMessage.IHistoryRequest = {
|
|
|
+ // output: true,
|
|
|
+ // raw: true,
|
|
|
+ // hist_access_type: 'search',
|
|
|
+ // session: 0,
|
|
|
+ // start: 1,
|
|
|
+ // stop: 2,
|
|
|
+ // n: 1,
|
|
|
+ // pattern: '*',
|
|
|
+ // unique: true,
|
|
|
+ // };
|
|
|
+ // let promise = kernel.requestHistory(options);
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('history_request');
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // tester.send(msg);
|
|
|
+ // });
|
|
|
+ // promise.then(() => { done(); });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#sendInputReply()', () => {
|
|
|
+
|
|
|
+ // it('should resolve the promise', (done) => {
|
|
|
+ // kernel.sendInputReply({ value: 'test' });
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.header.msg_type).to.be('input_reply');
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should fail if the kernel is dead', (done) => {
|
|
|
+ // tester.sendStatus('dead');
|
|
|
+ // kernel.statusChanged.connect(() => {
|
|
|
+ // try {
|
|
|
+ // kernel.sendInputReply({ value: 'test' });
|
|
|
+ // } catch (err) {
|
|
|
+ // expect(err.message).to.be('Kernel is dead');
|
|
|
+ // done();
|
|
|
+ // }
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#requestExecute()', () => {
|
|
|
+
|
|
|
+ // it('should send and handle incoming messages', (done) => {
|
|
|
+ // let newMsg: KernelMessage.IMessage;
|
|
|
+ // let content: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(content);
|
|
|
+ // expect(future.onDone).to.be(null);
|
|
|
+ // expect(future.onStdin).to.be(null);
|
|
|
+ // expect(future.onReply).to.be(null);
|
|
|
+ // expect(future.onIOPub).to.be(null);
|
|
|
+
|
|
|
+ // let options: KernelMessage.IOptions = {
|
|
|
+ // msgType: 'custom',
|
|
|
+ // channel: 'shell',
|
|
|
+ // username: kernel.username,
|
|
|
+ // session: kernel.clientId
|
|
|
+ // };
|
|
|
+
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.channel).to.be('shell');
|
|
|
+
|
|
|
+ // // send a reply
|
|
|
+ // options.channel = 'shell';
|
|
|
+ // newMsg = KernelMessage.createMessage(options);
|
|
|
+ // newMsg.parent_header = msg.header;
|
|
|
+ // tester.send(newMsg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onStdin
|
|
|
+ // options.channel = 'stdin';
|
|
|
+ // newMsg = KernelMessage.createMessage(options);
|
|
|
+ // newMsg.parent_header = msg.header;
|
|
|
+ // tester.send(newMsg);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onStdin = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // options.channel = 'iopub';
|
|
|
+ // options.msgType = 'stream';
|
|
|
+ // let streamContent: JSONObject = { name: 'stdout', text: '' };
|
|
|
+ // newMsg = KernelMessage.createMessage(options, streamContent);
|
|
|
+ // newMsg.parent_header = msg.header;
|
|
|
+ // tester.send(newMsg);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onIOPub = (ioMsg) => {
|
|
|
+ // if (ioMsg.header.msg_type === 'stream') {
|
|
|
+ // // trigger onDone
|
|
|
+ // options.msgType = 'status';
|
|
|
+ // newMsg = KernelMessage.createMessage(options, { execution_state: 'idle' });
|
|
|
+ // newMsg.parent_header = msg.header;
|
|
|
+ // tester.send(newMsg);
|
|
|
+ // }
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // doLater(() => {
|
|
|
+ // expect(future.isDisposed).to.be(true);
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should not dispose of KernelFuture when disposeOnDone=false', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // expect(future.onDone).to.be(null);
|
|
|
+ // expect(future.onStdin).to.be(null);
|
|
|
+ // expect(future.onReply).to.be(null);
|
|
|
+ // expect(future.onIOPub).to.be(null);
|
|
|
+
|
|
|
+ // tester.onMessage((msg) => {
|
|
|
+ // expect(msg.channel).to.be('shell');
|
|
|
+
|
|
|
+ // // send a reply
|
|
|
+ // msg.parent_header = msg.header;
|
|
|
+ // msg.channel = 'shell';
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // msg.channel = 'iopub';
|
|
|
+ // msg.header.msg_type = 'stream';
|
|
|
+ // msg.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msg);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // if (msg.header.msg_type === 'stream') {
|
|
|
+ // // trigger onDone
|
|
|
+ // msg.header.msg_type = 'status';
|
|
|
+ // (msg as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msg);
|
|
|
+ // }
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // doLater(() => {
|
|
|
+ // expect(future.isDisposed).to.be(false);
|
|
|
+ // expect(future.onDone).to.be(null);
|
|
|
+ // expect(future.onIOPub).to.not.be(null);
|
|
|
+ // future.dispose();
|
|
|
+ // expect(future.onIOPub).to.be(null);
|
|
|
+ // expect(future.isDisposed).to.be(true);
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+
|
|
|
+ // context('#registerMessageHook()', () => {
|
|
|
+
|
|
|
+ // it('should have the most recently registered hook run first', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
+ // calls.push('last');
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
+ // calls.push('first');
|
|
|
+ // // not returning should also continue handling
|
|
|
+ // return void 0;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // // the last hook was called for the stream and the status message.
|
|
|
+ // expect(calls).to.eql(['first', 'last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
+ // doLater(() => {
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should abort processing if a hook returns false, but the done logic should still work', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
+ // calls.push('last');
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
+ // calls.push('first');
|
|
|
+ // return false;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // // the last hook was called for the stream and the status message.
|
|
|
+ // expect(calls).to.eql(['first', 'first']);
|
|
|
+ // doLater(() => {
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should process additions on the next run', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
+ // calls.push('last');
|
|
|
+ // kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
+ // calls.push('first');
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // expect(calls).to.eql(['last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
+ // doLater(() => {
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should deactivate a hook immediately on removal', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // let toDelete = (msg: KernelMessage.IIOPubMessage) => {
|
|
|
+ // calls.push('delete');
|
|
|
+ // return true;
|
|
|
+ // }
|
|
|
+ // let toDeleteHook = kernel.registerMessageHook(parent_header.msg_id, toDelete);
|
|
|
+
|
|
|
+ // kernel.registerMessageHook(parent_header.msg_id, (msg) => {
|
|
|
+ // if (calls.length > 0) {
|
|
|
+ // // delete the hook the second time around
|
|
|
+ // toDeleteHook.dispose();
|
|
|
+ // }
|
|
|
+ // calls.push('first');
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // expect(calls).to.eql(['first', 'delete', 'iopub', 'first', 'iopub']);
|
|
|
+ // doLater(() => {
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // describe('IFuture', () => {
|
|
|
+
|
|
|
+ // beforeEach((done) => {
|
|
|
+ // Kernel.startNew().then(k => {
|
|
|
+ // kernel = k;
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should have a msg attribute', () => {
|
|
|
+ // let future = kernel.requestExecute({ code: 'hello' });
|
|
|
+ // expect(typeof future.msg.header.msg_id).to.be('string');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // describe('Message hooks', () => {
|
|
|
+
|
|
|
+ // it('should have the most recently registered hook run first', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // future.registerMessageHook((msg) => {
|
|
|
+ // calls.push('last');
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.registerMessageHook((msg) => {
|
|
|
+ // calls.push('first');
|
|
|
+ // // Check to make sure we actually got the messages we expected.
|
|
|
+ // if (msg.header.msg_type === 'stream') {
|
|
|
+ // expect((msg as KernelMessage.IStreamMsg).content.text).to.be('foo1');
|
|
|
+ // } else {
|
|
|
+ // expect((msg as KernelMessage.IStatusMsg).content.execution_state).to.be('idle');
|
|
|
+ // }
|
|
|
+ // // not returning should also continue handling
|
|
|
+ // return void 0;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // // the last hook was called for the stream and the status message.
|
|
|
+ // expect(calls).to.eql(['first', 'last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
+ // doLater(() => {
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should abort processing if a hook returns false, but the done logic should still work', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // future.registerMessageHook((msg) => {
|
|
|
+ // calls.push('last');
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.registerMessageHook((msg) => {
|
|
|
+ // calls.push('first');
|
|
|
+ // return false;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // // the last hook was called for the stream and the status message.
|
|
|
+ // expect(calls).to.eql(['first', 'first']);
|
|
|
+ // doLater(() => {
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should process additions on the next run', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // future.registerMessageHook((msg) => {
|
|
|
+ // calls.push('last');
|
|
|
+ // future.registerMessageHook((msg) => {
|
|
|
+ // calls.push('first');
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+ // return true;
|
|
|
+ // });
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // expect(calls).to.eql(['last', 'iopub', 'first', 'last', 'iopub']);
|
|
|
+ // doLater(() => {
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should deactivate message hooks immediately on removal', (done) => {
|
|
|
+ // let options: KernelMessage.IExecuteRequest = {
|
|
|
+ // code: 'test',
|
|
|
+ // silent: false,
|
|
|
+ // store_history: true,
|
|
|
+ // user_expressions: {},
|
|
|
+ // allow_stdin: false,
|
|
|
+ // stop_on_error: false
|
|
|
+ // };
|
|
|
+ // let future = kernel.requestExecute(options, false);
|
|
|
+ // tester.onMessage((message) => {
|
|
|
+ // // send a reply
|
|
|
+ // let parent_header = message.header;
|
|
|
+ // let msg = createMsg('shell', parent_header);
|
|
|
+ // tester.send(msg);
|
|
|
+
|
|
|
+ // future.onReply = () => {
|
|
|
+ // // trigger onIOPub with a 'stream' message
|
|
|
+ // let msgStream = createMsg('iopub', parent_header);
|
|
|
+ // msgStream.header.msg_type = 'stream';
|
|
|
+ // msgStream.content = { 'name': 'stdout', 'text': 'foo' };
|
|
|
+ // tester.send(msgStream);
|
|
|
+ // // trigger onDone
|
|
|
+ // let msgDone = createMsg('iopub', parent_header);
|
|
|
+ // msgDone.header.msg_type = 'status';
|
|
|
+ // (msgDone as KernelMessage.IStatusMsg).content.execution_state = 'idle';
|
|
|
+ // tester.send(msgDone);
|
|
|
+ // };
|
|
|
+
|
|
|
+ // let calls: string[] = [];
|
|
|
+ // let toDelete = (msg: KernelMessage.IIOPubMessage) => {
|
|
|
+ // calls.push('delete');
|
|
|
+ // return true;
|
|
|
+ // }
|
|
|
+ // future.registerMessageHook(toDelete);
|
|
|
+
|
|
|
+ // let first = (msg: KernelMessage.IIOPubMessage) => {
|
|
|
+ // if (calls.length > 0) {
|
|
|
+ // // delete the hook the second time around
|
|
|
+ // future.removeMessageHook(toDelete);
|
|
|
+ // }
|
|
|
+ // calls.push('first');
|
|
|
+ // return true;
|
|
|
+ // }
|
|
|
+ // future.registerMessageHook(first);
|
|
|
+
|
|
|
+ // future.onIOPub = () => {
|
|
|
+ // calls.push('iopub')
|
|
|
+ // };
|
|
|
+
|
|
|
+ // future.onDone = () => {
|
|
|
+ // expect(calls).to.eql(['first', 'delete', 'iopub', 'first', 'iopub']);
|
|
|
+ // doLater(() => {
|
|
|
+ // future.dispose();
|
|
|
+ // future.removeMessageHook(first);
|
|
|
+ // done();
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
+ // });
|
|
|
+
|
|
|
+ // describe('Kernel.getSpecs()', () => {
|
|
|
+
|
|
|
+ // it('should load the kernelspecs', (done) => {
|
|
|
+ // let ids = {
|
|
|
+ // 'python': PYTHON_SPEC,
|
|
|
+ // 'python3': PYTHON3_SPEC
|
|
|
+ // };
|
|
|
+ // tester.specs = { 'default': 'python',
|
|
|
+ // 'kernelspecs': ids };
|
|
|
+ // Kernel.getSpecs().then(specs => {
|
|
|
+ // let names = Object.keys(specs.kernelspecs);
|
|
|
+ // expect(names[0]).to.be('python');
|
|
|
+ // expect(names[1]).to.be('python3');
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should accept ajax options', (done) => {
|
|
|
+ // let ids = {
|
|
|
+ // 'python': PYTHON_SPEC,
|
|
|
+ // 'python3': PYTHON3_SPEC
|
|
|
+ // };
|
|
|
+ // tester.specs = { 'default': 'python',
|
|
|
+ // 'kernelspecs': ids };
|
|
|
+ // Kernel.getSpecs(serverSettings).then(specs => {
|
|
|
+ // let names = Object.keys(specs.kernelspecs);
|
|
|
+ // expect(names[0]).to.be('python');
|
|
|
+ // expect(names[1]).to.be('python3');
|
|
|
+ // done();
|
|
|
+ // }).catch(done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle a missing default parameter', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'kernelspecs': { 'python': PYTHON_SPEC } });
|
|
|
+ // };
|
|
|
+ // Kernel.getSpecs().then(specs => {
|
|
|
+ // expect(specs.default).to.be('python');
|
|
|
+ // }).then(done, done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw for a missing kernelspecs parameter', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'default': PYTHON_SPEC.name });
|
|
|
+ // };
|
|
|
+ // let promise = Kernel.getSpecs();
|
|
|
+ // expectAjaxError(promise, done, 'No kernelspecs found');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should omit an invalid kernelspec', (done) => {
|
|
|
+ // let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
+ // R_SPEC.name = 1;
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'default': 'python',
|
|
|
+ // 'kernelspecs': { 'R': R_SPEC,
|
|
|
+ // 'python': PYTHON_SPEC }
|
|
|
+ // });
|
|
|
+ // };
|
|
|
+ // Kernel.getSpecs().then(specs => {
|
|
|
+ // expect(specs.default).to.be('python');
|
|
|
+ // expect(specs.kernelspecs['R']).to.be(void 0);
|
|
|
+ // }).then(done, done);
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle an improper name', (done) => {
|
|
|
+ // let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
+ // R_SPEC.name = 1;
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'default': 'R',
|
|
|
+ // 'kernelspecs': { 'R': R_SPEC } });
|
|
|
+ // };
|
|
|
+ // let promise = Kernel.getSpecs();
|
|
|
+ // expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle an improper language', (done) => {
|
|
|
+ // let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
+ // R_SPEC.spec.language = 1;
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'default': 'R',
|
|
|
+ // 'kernelspecs': { 'R': R_SPEC } });
|
|
|
+ // };
|
|
|
+ // let promise = Kernel.getSpecs();
|
|
|
+ // expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle an improper argv', (done) => {
|
|
|
+ // let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
+ // R_SPEC.spec.argv = 'hello';
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'default': 'R',
|
|
|
+ // 'kernelspecs': { 'R': R_SPEC } });
|
|
|
+ // };
|
|
|
+ // let promise = Kernel.getSpecs();
|
|
|
+ // expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle an improper display_name', (done) => {
|
|
|
+ // let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
+ // R_SPEC.spec.display_name = ['hello'];
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'default': 'R',
|
|
|
+ // 'kernelspecs': { 'R': R_SPEC } });
|
|
|
+ // };
|
|
|
+ // let promise = Kernel.getSpecs();
|
|
|
+ // expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should handle missing resources', (done) => {
|
|
|
+ // let R_SPEC = JSON.parse(JSON.stringify(PYTHON_SPEC));
|
|
|
+ // delete R_SPEC.resources;
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(200, { 'default': 'R',
|
|
|
+ // 'kernelspecs': { 'R': R_SPEC } });
|
|
|
+ // };
|
|
|
+ // let promise = Kernel.getSpecs();
|
|
|
+ // expectAjaxError(promise, done, 'No valid kernelspecs found');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // it('should throw an error for an invalid response', (done) => {
|
|
|
+ // tester.onRequest = () => {
|
|
|
+ // tester.respond(201, { });
|
|
|
+ // };
|
|
|
+ // let promise = Kernel.getSpecs();
|
|
|
+ // expectAjaxError(promise, done, 'Invalid Status: 201');
|
|
|
+ // });
|
|
|
+
|
|
|
+ // });
|
|
|
|
|
|
});
|
Steven Silvester