FilesExpand file tree

 master

/

worker-manager.test.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

188 lines (154 loc) · 7.61 KB

 master

/

worker-manager.test.js

Copy path

Top

File metadata and controls

• Code
• Blame

188 lines (154 loc) · 7.61 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

import {remote} from 'electron';

const {BrowserWindow} = remote;

import WorkerManager, {Operation, Worker} from '../lib/worker-manager';

import {isProcessAlive} from './helpers';

describe('WorkerManager', function() {

let workerManager;

beforeEach(function() {

if (process.env.ATOM_GITHUB_INLINE_GIT_EXEC) {

this.skip();

return;

}

workerManager = new WorkerManager();

});

afterEach(function() {

workerManager.destroy(true);

});

describe('isReady()', function() {

it('returns true if its worker is ready', async function() {

assert.isFalse(workerManager.isReady());

await workerManager.getReadyPromise();

assert.isTrue(workerManager.isReady());

workerManager.onSick(workerManager.getActiveWorker());

assert.isFalse(workerManager.isReady());

await workerManager.getReadyPromise();

assert.isTrue(workerManager.isReady());

});

});

describe('when a worker process crashes', function() {

it('creates a new worker process (with the same operation count limit) and executes remaining operations', async function() {

workerManager.createNewWorker({operationCountLimit: 40});

sinon.stub(Operation.prototype, 'execute');

const worker1 = workerManager.getActiveWorker();

await worker1.getReadyPromise();

workerManager.request();

workerManager.request();

workerManager.request();

const worker1OperationsInFlight = worker1.getRemainingOperations();

assert.lengthOf(worker1OperationsInFlight, 3);

const worker1Pid = worker1.getPid();

process.kill(worker1Pid, 'SIGKILL');

await assert.async.notEqual(worker1, workerManager.getActiveWorker());

const worker2 = workerManager.getActiveWorker();

await worker2.getReadyPromise();

assert.notEqual(worker2.getPid(), worker1Pid);

assert.equal(worker2.getOperationCountLimit(), worker1.getOperationCountLimit());

assert.deepEqual(worker2.getRemainingOperations(), worker1OperationsInFlight);

});

});

describe('when a worker process is sick', function() {

it('creates a new worker with a new operation count limit that is based on the limit and completed operation count of the last worker', function() {

function createSickWorker(operationCountLimit, completedOperationCount) {

const sickWorker = workerManager.getActiveWorker();

sinon.stub(sickWorker, 'getOperationCountLimit').returns(operationCountLimit);

sinon.stub(sickWorker, 'getCompletedOperationCount').returns(completedOperationCount);

return sickWorker;

}

// when the last worker operation count limit was greater than or equal to the completed operation count

// this means that the average spawn time for the first operationCountLimit operations was already higher than the threshold

// the system is likely just slow, so we should increase the operationCountLimit so next time we do more operations before creating a new process

const sickWorker1 = createSickWorker(10, 9);

workerManager.onSick(sickWorker1);

assert.notEqual(sickWorker1, workerManager.getActiveWorker());

assert.equal(workerManager.getActiveWorker().getOperationCountLimit(), 20);

const sickWorker2 = createSickWorker(50, 50);

workerManager.onSick(sickWorker2);

assert.notEqual(sickWorker2, workerManager.getActiveWorker());

assert.equal(workerManager.getActiveWorker().getOperationCountLimit(), 100);

const sickWorker3 = createSickWorker(100, 100);

workerManager.onSick(sickWorker3);

assert.notEqual(sickWorker3, workerManager.getActiveWorker());

assert.equal(workerManager.getActiveWorker().getOperationCountLimit(), 100);

// when the last worker operation count limit was less than the completed operation count

// this means that the system is performing better and we can drop the operationCountLimit back down to the base limit

const sickWorker4 = createSickWorker(100, 150);

workerManager.onSick(sickWorker4);

assert.notEqual(sickWorker4, workerManager.getActiveWorker());

assert.equal(workerManager.getActiveWorker().getOperationCountLimit(), 10);

});

describe('when the sick process crashes', function() {

it('completes remaining operations in existing active process', function() {

const sickWorker = workerManager.getActiveWorker();

sinon.stub(Operation.prototype, 'execute');

workerManager.request();

workerManager.request();

workerManager.request();

const operationsInFlight = sickWorker.getRemainingOperations();

assert.equal(operationsInFlight.length, 3);

workerManager.onSick(sickWorker);

assert.notEqual(sickWorker, workerManager.getActiveWorker());

const newWorker = workerManager.getActiveWorker();

assert.equal(newWorker.getRemainingOperations(), 0);

workerManager.onCrashed(sickWorker);

assert.equal(workerManager.getActiveWorker(), newWorker);

assert.equal(newWorker.getRemainingOperations().length, 3);

});

});

});

describe('destroy', function() {

it('destroys the renderer processes created after they have completed their operations', async function() {

const worker1 = workerManager.getActiveWorker();

await worker1.getReadyPromise();

sinon.stub(Operation.prototype, 'execute');

workerManager.request();

workerManager.request();

workerManager.request();

const worker1Operations = worker1.getRemainingOperations();

assert.equal(worker1Operations.length, 3);

workerManager.onSick(worker1);

const worker2 = workerManager.getActiveWorker();

await worker2.getReadyPromise();

workerManager.request();

workerManager.request();

const worker2Operations = worker2.getRemainingOperations();

assert.equal(worker2Operations.length, 2);

workerManager.destroy();

assert.isTrue(isProcessAlive(worker1.getPid()));

assert.isTrue(isProcessAlive(worker2.getPid()));

[...worker1Operations, ...worker2Operations].forEach(operation => operation.complete());

await assert.async.isFalse(isProcessAlive(worker1.getPid()));

await assert.async.isFalse(isProcessAlive(worker2.getPid()));

});

});

describe('when the manager process is destroyed', function() {

it('destroys all the renderer processes that were created', async function() {

this.retries(5); // FLAKE

const browserWindow = new BrowserWindow({show: !!process.env.ATOM_GITHUB_SHOW_RENDERER_WINDOW, webPreferences: {nodeIntegration: true, enableRemoteModule: true}});

browserWindow.loadURL('about:blank');

sinon.stub(Worker.prototype, 'getWebContentsId').returns(browserWindow.webContents.id);

const script = `

const ipc = require('electron').ipcRenderer;

(function() {

ipc.on('${Worker.channelName}', function() {

const args = Array.prototype.slice.apply(arguments)

args.shift();

args.unshift('${Worker.channelName}');

args.unshift(${remote.getCurrentWebContents().id})

ipc.sendTo.apply(ipc, args);

});

})()

`;

await browserWindow.webContents.executeJavaScript(script);

workerManager.destroy(true);

workerManager = new WorkerManager();

const worker1 = workerManager.getActiveWorker();

await worker1.getReadyPromise();

workerManager.onSick(worker1);

const worker2 = workerManager.getActiveWorker();

await worker2.getReadyPromise();

browserWindow.destroy();

await assert.async.isFalse(isProcessAlive(worker1.getPid()));

await assert.async.isFalse(isProcessAlive(worker2.getPid()));

});

});

});