331 lines
14 KiB
TypeScript
331 lines
14 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
|
|
*/
|
|
import * as ts from 'typescript';
|
|
|
|
import {ErrorCode, makeDiagnostic} from '../../../src/ngtsc/diagnostics';
|
|
import {AbsoluteFsPath, absoluteFrom} from '../../../src/ngtsc/file_system';
|
|
import {runInEachFileSystem} from '../../../src/ngtsc/file_system/testing';
|
|
import {ClassDeclaration, Decorator} from '../../../src/ngtsc/reflection';
|
|
import {AnalysisOutput, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence} from '../../../src/ngtsc/transform';
|
|
import {DefaultMigrationHost} from '../../src/analysis/migration_host';
|
|
import {AnalyzedClass, AnalyzedFile} from '../../src/analysis/types';
|
|
import {NgccClassSymbol} from '../../src/host/ngcc_host';
|
|
import {createComponentDecorator} from '../../src/migrations/utils';
|
|
|
|
runInEachFileSystem(() => {
|
|
describe('DefaultMigrationHost', () => {
|
|
let _: typeof absoluteFrom;
|
|
let entryPointPath: AbsoluteFsPath;
|
|
let mockHost: any;
|
|
let mockMetadata: any = {};
|
|
let mockEvaluator: any = {};
|
|
let mockClazz: any;
|
|
let mockDecorator: any = {name: 'MockDecorator'};
|
|
let diagnosticHandler = () => {};
|
|
beforeEach(() => {
|
|
_ = absoluteFrom;
|
|
entryPointPath = _('/node_modules/some-package/entry-point');
|
|
mockHost = {
|
|
getClassSymbol: (node: any): NgccClassSymbol | undefined => {
|
|
const symbol = { valueDeclaration: node, name: node.name.text } as any;
|
|
return {
|
|
name: node.name.text,
|
|
declaration: symbol,
|
|
implementation: symbol,
|
|
};
|
|
},
|
|
};
|
|
const mockSourceFile: any = {
|
|
fileName: _('/node_modules/some-package/entry-point/test-file.js'),
|
|
};
|
|
mockClazz = {
|
|
name: {text: 'MockClazz'},
|
|
getSourceFile: () => mockSourceFile,
|
|
};
|
|
});
|
|
|
|
describe('injectSyntheticDecorator()', () => {
|
|
it('should call `detect()` on each of the provided handlers', () => {
|
|
const log: string[] = [];
|
|
const handler1 = new TestHandler('handler1', log);
|
|
const handler2 = new TestHandler('handler2', log);
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler1, handler2], entryPointPath, [],
|
|
diagnosticHandler);
|
|
host.injectSyntheticDecorator(mockClazz, mockDecorator);
|
|
expect(log).toEqual([
|
|
`handler1:detect:MockClazz:MockDecorator`,
|
|
`handler2:detect:MockClazz:MockDecorator`,
|
|
]);
|
|
});
|
|
|
|
it('should call `analyze()` on each of the provided handlers whose `detect()` call returns a result',
|
|
() => {
|
|
const log: string[] = [];
|
|
const handler1 = new TestHandler('handler1', log);
|
|
const handler2 = new AlwaysDetectHandler('handler2', log);
|
|
const handler3 = new TestHandler('handler3', log);
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler1, handler2, handler3],
|
|
entryPointPath, [], diagnosticHandler);
|
|
host.injectSyntheticDecorator(mockClazz, mockDecorator);
|
|
expect(log).toEqual([
|
|
`handler1:detect:MockClazz:MockDecorator`,
|
|
`handler2:detect:MockClazz:MockDecorator`,
|
|
`handler3:detect:MockClazz:MockDecorator`,
|
|
'handler2:analyze:MockClazz',
|
|
]);
|
|
});
|
|
|
|
it('should add a newly `AnalyzedFile` to the `analyzedFiles` object', () => {
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
host.injectSyntheticDecorator(mockClazz, mockDecorator);
|
|
expect(analyzedFiles.length).toEqual(1);
|
|
expect(analyzedFiles[0].analyzedClasses.length).toEqual(1);
|
|
expect(analyzedFiles[0].analyzedClasses[0].name).toEqual('MockClazz');
|
|
});
|
|
|
|
it('should add a newly `AnalyzedClass` to an existing `AnalyzedFile` object', () => {
|
|
const DUMMY_CLASS_1: any = {};
|
|
const DUMMY_CLASS_2: any = {};
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [{
|
|
sourceFile: mockClazz.getSourceFile(),
|
|
analyzedClasses: [DUMMY_CLASS_1, DUMMY_CLASS_2],
|
|
}];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
host.injectSyntheticDecorator(mockClazz, mockDecorator);
|
|
expect(analyzedFiles.length).toEqual(1);
|
|
expect(analyzedFiles[0].analyzedClasses.length).toEqual(3);
|
|
expect(analyzedFiles[0].analyzedClasses[2].name).toEqual('MockClazz');
|
|
});
|
|
|
|
it('should add a new decorator into an already existing `AnalyzedClass`', () => {
|
|
const analyzedClass: AnalyzedClass = {
|
|
name: 'MockClazz',
|
|
declaration: mockClazz,
|
|
matches: [],
|
|
decorators: null,
|
|
};
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [{
|
|
sourceFile: mockClazz.getSourceFile(),
|
|
analyzedClasses: [analyzedClass],
|
|
}];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
host.injectSyntheticDecorator(mockClazz, mockDecorator);
|
|
expect(analyzedFiles.length).toEqual(1);
|
|
expect(analyzedFiles[0].analyzedClasses.length).toEqual(1);
|
|
expect(analyzedFiles[0].analyzedClasses[0]).toBe(analyzedClass);
|
|
expect(analyzedClass.decorators !.length).toEqual(1);
|
|
expect(analyzedClass.decorators ![0].name).toEqual('MockDecorator');
|
|
});
|
|
|
|
it('should merge a new decorator into pre-existing decorators an already existing `AnalyzedClass`',
|
|
() => {
|
|
const analyzedClass: AnalyzedClass = {
|
|
name: 'MockClazz',
|
|
declaration: mockClazz,
|
|
matches: [],
|
|
decorators: [{name: 'OtherDecorator'} as Decorator],
|
|
};
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [{
|
|
sourceFile: mockClazz.getSourceFile(),
|
|
analyzedClasses: [analyzedClass],
|
|
}];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
host.injectSyntheticDecorator(mockClazz, mockDecorator);
|
|
expect(analyzedFiles.length).toEqual(1);
|
|
expect(analyzedFiles[0].analyzedClasses.length).toEqual(1);
|
|
expect(analyzedFiles[0].analyzedClasses[0]).toBe(analyzedClass);
|
|
expect(analyzedClass.decorators !.length).toEqual(2);
|
|
expect(analyzedClass.decorators ![1].name).toEqual('MockDecorator');
|
|
});
|
|
|
|
it('should throw an error if the injected decorator already exists', () => {
|
|
const analyzedClass: AnalyzedClass = {
|
|
name: 'MockClazz',
|
|
declaration: mockClazz,
|
|
matches: [],
|
|
decorators: [{name: 'MockDecorator'} as Decorator],
|
|
};
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [{
|
|
sourceFile: mockClazz.getSourceFile(),
|
|
analyzedClasses: [analyzedClass],
|
|
}];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
expect(() => host.injectSyntheticDecorator(mockClazz, mockDecorator))
|
|
.toThrow(jasmine.objectContaining(
|
|
{code: ErrorCode.NGCC_MIGRATION_DECORATOR_INJECTION_ERROR}));
|
|
});
|
|
|
|
it('should report diagnostics from handlers', () => {
|
|
const log: string[] = [];
|
|
const handler = new DiagnosticProducingHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [];
|
|
const diagnostics: ts.Diagnostic[] = [];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnostic => diagnostics.push(diagnostic));
|
|
mockClazz.getStart = () => 0;
|
|
mockClazz.getWidth = () => 0;
|
|
|
|
const decorator = createComponentDecorator(mockClazz, {selector: 'comp', exportAs: null});
|
|
host.injectSyntheticDecorator(mockClazz, decorator);
|
|
|
|
expect(diagnostics.length).toBe(1);
|
|
expect(ts.flattenDiagnosticMessageText(diagnostics[0].messageText, '\n'))
|
|
.toEqual(
|
|
`test diagnostic\n` +
|
|
` Occurs for @Component decorator inserted by an automatic migration\n` +
|
|
` @Component({ template: "", selector: "comp" })`);
|
|
});
|
|
});
|
|
|
|
describe('getAllDecorators', () => {
|
|
it('should be null for unknown source files', () => {
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
|
|
const decorators = host.getAllDecorators(mockClazz);
|
|
expect(decorators).toBeNull();
|
|
});
|
|
|
|
it('should be null for unknown classes', () => {
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const analyzedFiles: AnalyzedFile[] = [];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
|
|
const sourceFile: any = {};
|
|
const unrelatedClass: any = {
|
|
getSourceFile: () => sourceFile,
|
|
};
|
|
analyzedFiles.push({sourceFile, analyzedClasses: [unrelatedClass]});
|
|
|
|
const decorators = host.getAllDecorators(mockClazz);
|
|
expect(decorators).toBeNull();
|
|
});
|
|
|
|
it('should include injected decorators', () => {
|
|
const log: string[] = [];
|
|
const handler = new AlwaysDetectHandler('handler', log);
|
|
const existingDecorator = { name: 'ExistingDecorator' } as Decorator;
|
|
const analyzedClass: AnalyzedClass = {
|
|
name: 'MockClazz',
|
|
declaration: mockClazz,
|
|
matches: [],
|
|
decorators: [existingDecorator],
|
|
};
|
|
const analyzedFiles: AnalyzedFile[] = [{
|
|
sourceFile: mockClazz.getSourceFile(),
|
|
analyzedClasses: [analyzedClass],
|
|
}];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [handler], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
host.injectSyntheticDecorator(mockClazz, mockDecorator);
|
|
|
|
const decorators = host.getAllDecorators(mockClazz) !;
|
|
expect(decorators.length).toBe(2);
|
|
expect(decorators[0]).toBe(existingDecorator);
|
|
expect(decorators[1]).toBe(mockDecorator);
|
|
});
|
|
});
|
|
|
|
describe('isInScope', () => {
|
|
it('should be true for nodes within the entry-point', () => {
|
|
const analyzedFiles: AnalyzedFile[] = [];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
|
|
const sourceFile: any = {
|
|
fileName: _('/node_modules/some-package/entry-point/relative.js'),
|
|
};
|
|
const clazz: any = {
|
|
getSourceFile: () => sourceFile,
|
|
};
|
|
expect(host.isInScope(clazz)).toBe(true);
|
|
});
|
|
|
|
it('should be false for nodes outside the entry-point', () => {
|
|
const analyzedFiles: AnalyzedFile[] = [];
|
|
const host = new DefaultMigrationHost(
|
|
mockHost, mockMetadata, mockEvaluator, [], entryPointPath, analyzedFiles,
|
|
diagnosticHandler);
|
|
|
|
const sourceFile: any = {
|
|
fileName: _('/node_modules/some-package/other-entry/index.js'),
|
|
};
|
|
const clazz: any = {
|
|
getSourceFile: () => sourceFile,
|
|
};
|
|
expect(host.isInScope(clazz)).toBe(false);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
class TestHandler implements DecoratorHandler<unknown, unknown, unknown> {
|
|
constructor(readonly name: string, protected log: string[]) {}
|
|
|
|
precedence = HandlerPrecedence.PRIMARY;
|
|
detect(node: ClassDeclaration, decorators: Decorator[]|null): DetectResult<unknown>|undefined {
|
|
this.log.push(`${this.name}:detect:${node.name.text}:${decorators !.map(d => d.name)}`);
|
|
return undefined;
|
|
}
|
|
analyze(node: ClassDeclaration): AnalysisOutput<unknown> {
|
|
this.log.push(this.name + ':analyze:' + node.name.text);
|
|
return {};
|
|
}
|
|
compile(node: ClassDeclaration): CompileResult|CompileResult[] {
|
|
this.log.push(this.name + ':compile:' + node.name.text);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
class AlwaysDetectHandler extends TestHandler {
|
|
detect(node: ClassDeclaration, decorators: Decorator[]|null): DetectResult<unknown>|undefined {
|
|
super.detect(node, decorators);
|
|
return {trigger: node, metadata: {}};
|
|
}
|
|
}
|
|
|
|
class DiagnosticProducingHandler extends AlwaysDetectHandler {
|
|
analyze(node: ClassDeclaration): AnalysisOutput<any> {
|
|
super.analyze(node);
|
|
return {diagnostics: [makeDiagnostic(9999, node, 'test diagnostic')]};
|
|
}
|
|
}
|