Joey Perrott d1ea1f4c7f build: update license headers to reference Google LLC ()
Update the license headers throughout the repository to reference Google LLC
rather than Google Inc, for the required license headers.

PR Close 
2020-05-26 14:26:58 -04:00

286 lines
10 KiB
TypeScript

/**
* @license
* Copyright Google LLC 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 {ivyEnabled} from '@angular/private/testing';
import * as fs from 'fs';
import * as path from 'path';
import * as ts from 'typescript';
import * as ng from '../index';
import {FileChangeEvent, performWatchCompilation} from '../src/perform_watch';
import {expectNoDiagnostics, setup, TestSupport} from './test_support';
describe('perform watch', () => {
let testSupport: TestSupport;
let outDir: string;
beforeEach(() => {
testSupport = setup();
outDir = path.resolve(testSupport.basePath, 'outDir');
});
function createConfig(overrideOptions: ng.CompilerOptions = {}): ng.ParsedConfiguration {
const options = testSupport.createCompilerOptions({outDir, ...overrideOptions});
return {
options,
rootNames: [path.resolve(testSupport.basePath, 'src/index.ts')],
project: path.resolve(testSupport.basePath, 'src/tsconfig.json'),
emitFlags: ng.EmitFlags.Default,
errors: []
};
}
it('should compile files during the initial run', () => {
const config = createConfig();
const host = new MockWatchHost(config);
testSupport.writeFiles({
'src/main.ts': createModuleAndCompSource('main'),
'src/index.ts': `export * from './main'; `,
});
const watchResult = performWatchCompilation(host);
expectNoDiagnostics(config.options, watchResult.firstCompileResult);
expect(fs.existsSync(path.resolve(outDir, 'src', 'main.ngfactory.js'))).toBe(true);
});
it('should recompile components when its template changes', () => {
const config = createConfig({enableIvy: ivyEnabled});
const host = new MockWatchHost(config);
testSupport.writeFiles({
'src/main.ts': createModuleAndCompSource('main', './main.html'),
'src/main.html': 'initial',
'src/index.ts': `export * from './main'; `,
});
const watchResult = performWatchCompilation(host);
expectNoDiagnostics(config.options, watchResult.firstCompileResult);
const htmlPath = path.join(testSupport.basePath, 'src', 'main.html');
const genPath = ivyEnabled ? path.posix.join(outDir, 'src', 'main.js') :
path.posix.join(outDir, 'src', 'main.ngfactory.js');
const initial = fs.readFileSync(genPath, {encoding: 'utf8'});
expect(initial).toContain('"initial"');
testSupport.write(htmlPath, 'updated');
host.triggerFileChange(FileChangeEvent.Change, htmlPath);
const updated = fs.readFileSync(genPath, {encoding: 'utf8'});
expect(updated).toContain('"updated"');
});
it('should cache files on subsequent runs', () => {
const config = createConfig();
const host = new MockWatchHost(config);
let fileExistsSpy: jasmine.Spy;
let getSourceFileSpy: jasmine.Spy;
host.createCompilerHost = (options: ng.CompilerOptions) => {
const ngHost = ng.createCompilerHost({options});
fileExistsSpy = spyOn(ngHost, 'fileExists').and.callThrough();
getSourceFileSpy = spyOn(ngHost, 'getSourceFile').and.callThrough();
return ngHost;
};
testSupport.writeFiles({
'src/main.ts': createModuleAndCompSource('main'),
'src/util.ts': `export const x = 1;`,
'src/index.ts': `
export * from './main';
export * from './util';
`,
});
const mainTsPath = path.posix.join(testSupport.basePath, 'src', 'main.ts');
const utilTsPath = path.posix.join(testSupport.basePath, 'src', 'util.ts');
const mainNgFactory = path.posix.join(outDir, 'src', 'main.ngfactory.js');
performWatchCompilation(host);
expect(fs.existsSync(mainNgFactory)).toBe(true);
expect(fileExistsSpy!).toHaveBeenCalledWith(mainTsPath);
expect(fileExistsSpy!).toHaveBeenCalledWith(utilTsPath);
expect(getSourceFileSpy!).toHaveBeenCalledWith(mainTsPath, ts.ScriptTarget.ES5);
expect(getSourceFileSpy!).toHaveBeenCalledWith(utilTsPath, ts.ScriptTarget.ES5);
fileExistsSpy!.calls.reset();
getSourceFileSpy!.calls.reset();
// trigger a single file change
// -> all other files should be cached
host.triggerFileChange(FileChangeEvent.Change, utilTsPath);
expectNoDiagnostics(config.options, host.diagnostics);
expect(fileExistsSpy!).not.toHaveBeenCalledWith(mainTsPath);
expect(fileExistsSpy!).toHaveBeenCalledWith(utilTsPath);
expect(getSourceFileSpy!).not.toHaveBeenCalledWith(mainTsPath, ts.ScriptTarget.ES5);
expect(getSourceFileSpy!).toHaveBeenCalledWith(utilTsPath, ts.ScriptTarget.ES5);
// trigger a folder change
// -> nothing should be cached
host.triggerFileChange(
FileChangeEvent.CreateDeleteDir, path.resolve(testSupport.basePath, 'src'));
expectNoDiagnostics(config.options, host.diagnostics);
expect(fileExistsSpy!).toHaveBeenCalledWith(mainTsPath);
expect(fileExistsSpy!).toHaveBeenCalledWith(utilTsPath);
expect(getSourceFileSpy!).toHaveBeenCalledWith(mainTsPath, ts.ScriptTarget.ES5);
expect(getSourceFileSpy!).toHaveBeenCalledWith(utilTsPath, ts.ScriptTarget.ES5);
});
// https://github.com/angular/angular/pull/26036
it('should handle redirected source files', () => {
const config = createConfig();
const host = new MockWatchHost(config);
host.createCompilerHost = (options: ng.CompilerOptions) => {
const ngHost = ng.createCompilerHost({options});
return ngHost;
};
// This file structure has an identical version of "a" under the root node_modules and inside
// of "b". Because their package.json file indicates it is the exact same version of "a",
// TypeScript will transform the source file of "node_modules/b/node_modules/a/index.d.ts"
// into a redirect to "node_modules/a/index.d.ts". During watch compilations, we must assure
// not to reintroduce "node_modules/b/node_modules/a/index.d.ts" as its redirected source file,
// but instead using its original file.
testSupport.writeFiles({
'node_modules/a/index.js': `export class ServiceA {}`,
'node_modules/a/index.d.ts': `export declare class ServiceA {}`,
'node_modules/a/package.json': `{"name": "a", "version": "1.0"}`,
'node_modules/b/node_modules/a/index.js': `export class ServiceA {}`,
'node_modules/b/node_modules/a/index.d.ts': `export declare class ServiceA {}`,
'node_modules/b/node_modules/a/package.json': `{"name": "a", "version": "1.0"}`,
'node_modules/b/index.js': `export {ServiceA as ServiceB} from 'a';`,
'node_modules/b/index.d.ts': `export {ServiceA as ServiceB} from 'a';`,
'src/index.ts': `
import {ServiceA} from 'a';
import {ServiceB} from 'b';
`,
});
const indexTsPath = path.posix.join(testSupport.basePath, 'src', 'index.ts');
performWatchCompilation(host);
// Trigger a file change. This recreates the program from the old program. If redirect sources
// were introduced into the new program, this would fail due to an assertion failure in TS.
host.triggerFileChange(FileChangeEvent.Change, indexTsPath);
expectNoDiagnostics(config.options, host.diagnostics);
});
it('should recover from static analysis errors', () => {
const config = createConfig();
const host = new MockWatchHost(config);
const okFileContent = `
import {NgModule} from '@angular/core';
@NgModule()
export class MyModule {}
`;
const errorFileContent = `
import {NgModule} from '@angular/core';
@NgModule((() => (1===1 ? null as any : null as any)) as any)
export class MyModule {}
`;
const indexTsPath = path.resolve(testSupport.basePath, 'src', 'index.ts');
testSupport.write(indexTsPath, okFileContent);
performWatchCompilation(host);
expectNoDiagnostics(config.options, host.diagnostics);
// Do it multiple times as the watch mode switches internal modes.
// E.g. from regular compile to using summaries, ...
for (let i = 0; i < 3; i++) {
host.diagnostics = [];
testSupport.write(indexTsPath, okFileContent);
host.triggerFileChange(FileChangeEvent.Change, indexTsPath);
expectNoDiagnostics(config.options, host.diagnostics);
host.diagnostics = [];
testSupport.write(indexTsPath, errorFileContent);
host.triggerFileChange(FileChangeEvent.Change, indexTsPath);
const errDiags = host.diagnostics.filter(d => d.category === ts.DiagnosticCategory.Error);
expect(errDiags.length).toBe(1);
expect(errDiags[0].messageText).toContain('Function expressions are not supported');
}
});
});
function createModuleAndCompSource(prefix: string, template: string = prefix + 'template') {
const templateEntry =
template.endsWith('.html') ? `templateUrl: '${template}'` : `template: \`${template}\``;
return `
import {Component, NgModule} from '@angular/core';
@Component({selector: '${prefix}', ${templateEntry}})
export class ${prefix}Comp {}
@NgModule({declarations: [${prefix}Comp]})
export class ${prefix}Module {}
`;
}
class MockWatchHost {
nextTimeoutListenerId = 1;
timeoutListeners: {[id: string]: (() => void)} = {};
fileChangeListeners: Array<((event: FileChangeEvent, fileName: string) => void)|null> = [];
diagnostics: ng.Diagnostic[] = [];
constructor(public config: ng.ParsedConfiguration) {}
reportDiagnostics(diags: ng.Diagnostics) {
this.diagnostics.push(...(diags as ng.Diagnostic[]));
}
readConfiguration() {
return this.config;
}
createCompilerHost(options: ng.CompilerOptions) {
return ng.createCompilerHost({options});
}
createEmitCallback() {
return undefined;
}
onFileChange(
options: ng.CompilerOptions, listener: (event: FileChangeEvent, fileName: string) => void,
ready: () => void) {
const id = this.fileChangeListeners.length;
this.fileChangeListeners.push(listener);
ready();
return {
close: () => this.fileChangeListeners[id] = null,
};
}
setTimeout(callback: () => void): any {
const id = this.nextTimeoutListenerId++;
this.timeoutListeners[id] = callback;
return id;
}
clearTimeout(timeoutId: any): void {
delete this.timeoutListeners[timeoutId];
}
flushTimeouts() {
const listeners = this.timeoutListeners;
this.timeoutListeners = {};
Object.keys(listeners).forEach(id => listeners[id]());
}
triggerFileChange(event: FileChangeEvent, fileName: string) {
this.fileChangeListeners.forEach(listener => {
if (listener) {
listener(event, fileName);
}
});
this.flushTimeouts();
}
}