angular-cn/packages/compiler-cli/ngcc/test/execution/cluster/worker_spec.ts

214 lines
7.6 KiB
TypeScript

/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/// <reference types="node" />
import * as cluster from 'cluster';
import {EventEmitter} from 'events';
import {AbsoluteFsPath} from '../../../../src/ngtsc/file_system';
import {CreateCompileFn} from '../../../src/execution/api';
import {startWorker} from '../../../src/execution/cluster/worker';
import {Task, TaskCompletedCallback, TaskProcessingOutcome} from '../../../src/execution/tasks/api';
import {FileToWrite} from '../../../src/rendering/utils';
import {MockLogger} from '../../helpers/mock_logger';
import {mockProperty, spyProperty} from '../../helpers/spy_utils';
describe('startWorker()', () => {
const runAsClusterMaster = mockProperty(cluster, 'isMaster');
const mockProcessSend = mockProperty(process, 'send');
let processSendSpy: jasmine.Spy;
let compileFnSpy: jasmine.Spy;
let createCompileFnSpy: jasmine.Spy;
let mockLogger: MockLogger;
beforeEach(() => {
compileFnSpy = jasmine.createSpy('compileFn');
createCompileFnSpy = jasmine.createSpy('createCompileFn').and.returnValue(compileFnSpy);
processSendSpy = jasmine.createSpy('process.send');
mockProcessSend(processSendSpy);
mockLogger = new MockLogger();
});
describe('(on cluster master)', () => {
beforeEach(() => runAsClusterMaster(true));
it('should throw an error', async () => {
await expectAsync(startWorker(mockLogger, createCompileFnSpy))
.toBeRejectedWithError('Tried to run cluster worker on the master process.');
expect(createCompileFnSpy).not.toHaveBeenCalled();
});
});
describe('(on cluster worker)', () => {
// The `cluster.worker` property is normally `undefined` on the master process and set to the
// current `cluster.worker` on worker processes.
const mockClusterWorker = mockProperty(cluster, 'worker');
beforeEach(() => {
runAsClusterMaster(false);
mockClusterWorker(Object.assign(new EventEmitter(), {id: 42}) as cluster.Worker);
});
it('should create the `compileFn()`', () => {
startWorker(mockLogger, createCompileFnSpy);
expect(createCompileFnSpy).toHaveBeenCalledWith(jasmine.any(Function), jasmine.any(Function));
});
it('should set up `compileFn()` to send `transformed-files` messages to master', () => {
startWorker(mockLogger, createCompileFnSpy);
const mockTransformedFiles: FileToWrite[] = [
{path: '/foo' as AbsoluteFsPath, contents: 'FOO'},
{path: '/bar' as AbsoluteFsPath, contents: 'BAR'},
];
const beforeWritingFiles: Parameters<CreateCompileFn>[0] =
createCompileFnSpy.calls.argsFor(0)[0];
beforeWritingFiles(mockTransformedFiles);
expect(processSendSpy).toHaveBeenCalledTimes(1);
expect(processSendSpy)
.toHaveBeenCalledWith(
{type: 'transformed-files', files: ['/foo', '/bar']}, jasmine.any(Function));
});
it('should set up `compileFn()` to send `task-completed` messages to master', () => {
startWorker(mockLogger, createCompileFnSpy);
const onTaskCompleted: TaskCompletedCallback = createCompileFnSpy.calls.argsFor(0)[1];
onTaskCompleted(null as any, TaskProcessingOutcome.Processed, null);
expect(processSendSpy).toHaveBeenCalledTimes(1);
expect(processSendSpy)
.toHaveBeenCalledWith(
{type: 'task-completed', outcome: TaskProcessingOutcome.Processed, message: null},
jasmine.any(Function));
processSendSpy.calls.reset();
onTaskCompleted(null as any, TaskProcessingOutcome.Failed, 'error message');
expect(processSendSpy).toHaveBeenCalledTimes(1);
expect(processSendSpy)
.toHaveBeenCalledWith(
{
type: 'task-completed',
outcome: TaskProcessingOutcome.Failed,
message: 'error message',
},
jasmine.any(Function));
});
it('should return a promise (that is never resolved)', done => {
const promise = startWorker(mockLogger, createCompileFnSpy);
expect(promise).toEqual(jasmine.any(Promise));
promise.then(
() => done.fail('Expected promise not to resolve'),
() => done.fail('Expected promise not to reject'));
// We can't wait forever to verify that the promise is not resolved, but at least verify
// that it is not resolved immediately.
setTimeout(done, 100);
});
it('should handle `process-task` messages', () => {
const mockTask = {
entryPoint: {name: 'foo'},
formatProperty: 'es2015',
processDts: true,
} as unknown as Task;
startWorker(mockLogger, createCompileFnSpy);
cluster.worker.emit('message', {type: 'process-task', task: mockTask});
expect(compileFnSpy).toHaveBeenCalledWith(mockTask);
expect(processSendSpy).not.toHaveBeenCalled();
expect(mockLogger.logs.debug[0]).toEqual([
'[Worker #42] Processing task: {entryPoint: foo, formatProperty: es2015, processDts: true}',
]);
});
it('should send errors during task processing back to the master process', () => {
const mockTask = {
entryPoint: {name: 'foo'},
formatProperty: 'es2015',
processDts: true,
} as unknown as Task;
let err: string|Error;
compileFnSpy.and.callFake(() => {
throw err;
});
startWorker(mockLogger, createCompileFnSpy);
err = 'Error string.';
cluster.worker.emit('message', {type: 'process-task', task: mockTask});
expect(processSendSpy)
.toHaveBeenCalledWith({type: 'error', error: err}, jasmine.any(Function));
err = new Error('Error object.');
cluster.worker.emit('message', {type: 'process-task', task: mockTask});
expect(processSendSpy)
.toHaveBeenCalledWith({type: 'error', error: err.stack}, jasmine.any(Function));
});
it('should exit on `ENOMEM` errors during task processing', () => {
const processExitSpy = jasmine.createSpy('process.exit');
const {
setMockValue: mockProcessExit,
installSpies: installProcessExitSpies,
uninstallSpies: uninstallProcessExitSpies,
} = spyProperty(process, 'exit');
try {
installProcessExitSpies();
mockProcessExit(processExitSpy as unknown as typeof process.exit);
const mockTask = {
entryPoint: {name: 'foo'},
formatProperty: 'es2015',
processDts: true,
} as unknown as Task;
const noMemError = Object.assign(new Error('ENOMEM: not enough memory'), {code: 'ENOMEM'});
compileFnSpy.and.throwError(noMemError);
startWorker(mockLogger, createCompileFnSpy);
cluster.worker.emit('message', {type: 'process-task', task: mockTask});
expect(mockLogger.logs.warn).toEqual([[`[Worker #42] ${noMemError.stack}`]]);
expect(processExitSpy).toHaveBeenCalledWith(1);
expect(processSendSpy).not.toHaveBeenCalled();
} finally {
uninstallProcessExitSpies();
}
});
it('should throw, when an unknown message type is received', () => {
startWorker(mockLogger, createCompileFnSpy);
cluster.worker.emit('message', {type: 'unknown', foo: 'bar'});
expect(compileFnSpy).not.toHaveBeenCalled();
expect(processSendSpy)
.toHaveBeenCalledWith(
{
type: 'error',
error: jasmine.stringMatching(
'Error: \\[Worker #42\\] Invalid message received: {"type":"unknown","foo":"bar"}'),
},
jasmine.any(Function));
});
});
});