/
manager.spec.ts
191 lines (165 loc) · 5.84 KB
/
manager.spec.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
// Copyright (c) Jupyter Development Team.
// Distributed under the terms of the Modified BSD License.
import { expect } from 'chai';
import { toArray } from '@lumino/algorithm';
import { KernelManager, Kernel, KernelAPI } from '@jupyterlab/services';
import { testEmission, sleep } from '@jupyterlab/testutils';
import { makeSettings } from '../utils';
describe('kernel/manager', () => {
let manager: KernelManager;
let kernel: Kernel.IModel;
beforeAll(async () => {
jest.setTimeout(2400000);
kernel = await KernelAPI.startNew();
});
beforeEach(() => {
manager = new KernelManager({ standby: 'never' });
return manager.ready;
});
afterEach(() => {
manager.dispose();
});
afterAll(async () => {
let models = await KernelAPI.listRunning();
await Promise.all(models.map(m => KernelAPI.shutdownKernel(m.id)));
});
describe('KernelManager', () => {
describe('#constructor()', () => {
it('should take the options as an argument', async () => {
manager.dispose();
manager = new KernelManager({
serverSettings: makeSettings(),
standby: 'never'
});
expect(manager instanceof KernelManager).to.equal(true);
await manager.ready;
});
});
describe('#serverSettings', () => {
it('should get the server settings', async () => {
manager.dispose();
const serverSettings = makeSettings();
const standby = 'never';
const token = serverSettings.token;
manager = new KernelManager({ serverSettings, standby });
await manager.ready;
expect(manager.serverSettings.token).to.equal(token);
});
});
describe('#running()', () => {
it('should get the running sessions', async () => {
await manager.refreshRunning();
expect(toArray(manager.running()).length).to.be.greaterThan(0);
});
});
describe('#runningChanged', () => {
it('should be emitted in refreshRunning when the running kernels changed', async () => {
let called = false;
manager.runningChanged.connect((sender, args) => {
expect(sender).to.equal(manager);
expect(toArray(args).length).to.be.greaterThan(0);
called = true;
});
await KernelAPI.startNew();
await manager.refreshRunning();
expect(called).to.equal(true);
});
it('should be emitted when a kernel is shut down', async () => {
const kernel = await manager.startNew();
await kernel.info;
let called = false;
manager.runningChanged.connect(() => {
called = true;
});
await manager.shutdown(kernel.id);
expect(called).to.equal(true);
});
});
describe('#isReady', () => {
it('should test whether the manager is ready', async () => {
manager.dispose();
manager = new KernelManager({ standby: 'never' });
expect(manager.isReady).to.equal(false);
await manager.ready;
expect(manager.isReady).to.equal(true);
});
});
describe('#ready', () => {
it('should resolve when the manager is ready', () => {
return manager.ready;
});
});
describe('#refreshRunning()', () => {
it('should update the running kernels', async () => {
await manager.refreshRunning();
expect(toArray(manager.running()).length).to.be.greaterThan(0);
});
it('should update the running kernels when one is shut down', async () => {
const old = toArray(manager.running()).length;
await KernelAPI.startNew();
await manager.refreshRunning();
expect(toArray(manager.running()).length).to.be.greaterThan(old);
});
});
describe('#startNew()', () => {
it('should start a new kernel', () => {
return manager.startNew();
});
it('should emit a runningChanged signal', async () => {
let called = false;
manager.runningChanged.connect(() => {
called = true;
});
let kernel = await manager.startNew();
await kernel.info;
expect(called).to.equal(true);
});
});
describe('#findById()', () => {
it('should find an existing kernel by id', async () => {
const id = kernel.id;
const model = await manager.findById(id);
expect(model.id).to.equal(id);
});
});
describe('#connectTo()', () => {
it('should connect to an existing kernel', () => {
const id = kernel.id;
const newConnection = manager.connectTo({ model: kernel });
expect(newConnection.model.id).to.equal(id);
});
});
describe('shutdown()', () => {
it('should shut down a kernel by id', async () => {
const kernel = await manager.startNew();
await kernel.info;
await manager.shutdown(kernel.id);
expect(kernel.isDisposed).to.equal(true);
});
it('should emit a runningChanged signal', async () => {
const kernel = await manager.startNew();
const emission = testEmission(manager.runningChanged, {
test: () => {
expect(kernel.isDisposed).to.equal(false);
}
});
await kernel.info;
await manager.shutdown(kernel.id);
await emission;
});
it('should dispose of all relevant kernel connections', async () => {
const kernel0 = await manager.startNew();
const kernel1 = manager.connectTo({ model: kernel0.model });
await kernel0.info;
await kernel1.info;
await kernel0.shutdown();
expect(kernel0.status).to.equal('dead');
expect(kernel0.isDisposed).to.equal(true);
// Wait for the round trip to the server to update the connections.
await sleep(100);
expect(kernel1.status).to.equal('dead');
expect(kernel1.isDisposed).to.equal(true);
});
});
});
});