refactor(@angular-devkit/architect): remove deprecated TestLogger

BREAKING CHANGE:

Deprecated `TestLogger` has been removed. Use `logging` API from `'@angular-devkit/core'` instead.

**Note:** this change doesn't effect application developers.

Author: alan-agius4

etc/api/angular_devkit/architect/testing/index.d.ts

@@ -14,13 +14,6 @@ export declare class TestingArchitectHost implements ArchitectHost {
     resolveBuilder(builderName: string): Promise<BuilderInfo | null>;
 }
 
-export declare class TestLogger extends logging.Logger {
-    constructor(name: string, parent?: logging.Logger | null);
-    clear(): void;
-    includes(message: string): boolean;
-    test(re: RegExp): boolean;
-}
-
 export declare class TestProjectHost extends NodeJsSyncHost {
     protected _templateRoot: Path;
     constructor(_templateRoot: Path);

packages/angular_devkit/architect/testing/index.ts

@@ -7,4 +7,3 @@
  */
 export * from './testing-architect-host';
 export * from './test-project-host';
-export * from './test-logger';

packages/angular_devkit/architect/testing/test-logger.ts

@@ -7,7 +7,8 @@
  */
 
 import { Architect } from '@angular-devkit/architect';
-import { TestLogger, TestProjectHost } from '@angular-devkit/architect/testing';
+import { TestProjectHost } from '@angular-devkit/architect/testing';
+import { logging } from '@angular-devkit/core';
 import { take, tap, timeout } from 'rxjs/operators';
 import {
   browserBuild,
@@ -45,12 +46,12 @@ describe('Browser Builder lazy modules', () => {
     );
   }
 
-  function hasMissingModuleError(logger: TestLogger) {
+  function hasMissingModuleError(logs: string): boolean {
     // TS type error when using import().
-    return logger.includes('Cannot find module') ||
+    return logs.includes('Cannot find module') ||
       // Webpack error when using import() on a rebuild.
       // There is no TS error because the type checker is forked on rebuilds.
-      logger.includes('Module not found');
+      logs.includes('Module not found');
   }
 
   const cases: [string, Record<string, string>][] = [
@@ -96,21 +97,24 @@ describe('Browser Builder lazy modules', () => {
       host.writeMultipleFiles(lazyModuleFnImport);
       host.replaceInFile('src/app/app.module.ts', 'lazy.module', 'invalid.module');
 
-      const logger = new TestLogger('build-lazy-errors');
+      const logger = new logging.Logger('');
+      const logs: string[] = [];
+      logger.subscribe(e => logs.push(e.message));
+
       const run = await architect.scheduleTarget(target, {}, { logger });
       const output = await run.result;
       expect(output.success).toBe(false);
-      expect(hasMissingModuleError(logger)).toBe(true, 'Should show missing module error');
+      expect(hasMissingModuleError(logs.join())).toBe(true, 'Should show missing module error');
     });
 
     it('should show error when lazy route is invalid on watch mode AOT', async () => {
       host.writeMultipleFiles(lazyModuleFiles);
       host.writeMultipleFiles(lazyModuleFnImport);
 
       let buildNumber = 0;
-      const logger = new TestLogger('rebuild-lazy-errors');
+
       const overrides = { watch: true, aot: true };
-      const run = await architect.scheduleTarget(target, overrides, { logger });
+      const run = await architect.scheduleTarget(target, overrides);
       await run.output
         .pipe(
           timeout(15000),
@@ -120,7 +124,6 @@ describe('Browser Builder lazy modules', () => {
               case 1:
                 expect(buildEvent.success).toBe(true);
                 host.replaceInFile('src/app/app.module.ts', 'lazy.module', 'invalid.module');
-                logger.clear();
                 break;
               case 2:
                 expect(buildEvent.success).toBe(false);

packages/angular_devkit/build_angular/src/browser/specs/lazy-module_spec.ts

@@ -7,7 +7,7 @@
  */
 
 import { Architect } from '@angular-devkit/architect';
-import { TestLogger } from '@angular-devkit/architect/testing';
+import { logging } from '@angular-devkit/core';
 import { browserBuild, createArchitect, host, veEnabled } from '../../test-utils';
 
 describe('Browser Builder no entry module', () => {
@@ -38,8 +38,11 @@ describe('Browser Builder no entry module', () => {
     host.replaceInFile('src/main.ts', /./g, '');
     host.appendToFile('src/main.ts', `import './app/app.module';`);
 
-    const logger = new TestLogger('no-bootstrap');
+    const logger = new logging.Logger('');
+    const logs: string[] = [];
+    logger.subscribe(e => logs.push(e.message));
+
     await browserBuild(architect, host, target, { baseHref: '/myUrl' }, { logger });
-    expect(logger.includes('Lazy routes discovery is not enabled')).toBe(true);
+    expect(logs.join().includes('Lazy routes discovery is not enabled')).toBe(true);
   });
 });

packages/angular_devkit/build_angular/src/browser/specs/no-entry-module_spec.ts

@@ -7,8 +7,7 @@
  */
 // tslint:disable:no-big-function
 import { Architect } from '@angular-devkit/architect';
-import { TestLogger } from '@angular-devkit/architect/testing';
-import { join, normalize, virtualFs } from '@angular-devkit/core';
+import { join, logging, normalize, virtualFs } from '@angular-devkit/core';
 import { debounceTime, take, takeWhile, tap } from 'rxjs/operators';
 import {
   createArchitect,
@@ -154,7 +153,10 @@ describe('Browser Builder rebuilds', () => {
     );
 
     const overrides = { watch: true, forkTypeChecker: false };
-    const logger = new TestLogger('rebuild-type-errors');
+    const logger = new logging.Logger('');
+    let logs: string[] = [];
+    logger.subscribe(e => logs.push(e.message));
+
     const typeError = `is not assignable to parameter of type 'number'`;
     let buildNumber = 0;
 
@@ -177,8 +179,8 @@ describe('Browser Builder rebuilds', () => {
             case 2:
               // The second build should error out with a type error on the type of an argument.
               expect(buildEvent.success).toBe(false);
-              expect(logger.includes(typeError)).toBe(true);
-              logger.clear();
+              expect(logs.join().includes(typeError)).toBe(true);
+              logs = [];
               // Change an UNRELATED file and the error should still happen.
               // Should trigger a rebuild, this time an error is also expected.
               host.appendToFile('src/app/app.module.ts', `console.log(1);`);
@@ -187,8 +189,8 @@ describe('Browser Builder rebuilds', () => {
             case 3:
               // The third build should have the same error as the first.
               expect(buildEvent.success).toBe(false);
-              expect(logger.includes(typeError)).toBe(true);
-              logger.clear();
+              expect(logs.join().includes(typeError)).toBe(true);
+              logs = [];
               // Fix the error.
               host.writeMultipleFiles({
                 'src/funky2.ts': `export const funky2 = (value: string) => value + 'hello';`,
@@ -350,7 +352,9 @@ describe('Browser Builder rebuilds', () => {
     // show up in getNgSemanticDiagnostics. Since getNgSemanticDiagnostics is only called on the
     // type checker, we must disable it to get a failing fourth build with Ivy.
     const overrides = { watch: true, aot: true, forkTypeChecker: veEnabled };
-    const logger = new TestLogger('rebuild-aot-errors');
+    const logger = new logging.Logger('');
+    let logs: string[] = [];
+    logger.subscribe(e => logs.push(e.message));
     const staticAnalysisError = !veEnabled
       ? 'selector must be a string'
       : 'Function expressions are not supported in decorators';
@@ -367,30 +371,30 @@ describe('Browser Builder rebuilds', () => {
             case 1:
               // The first build should error out with a static analysis error.
               expect(buildEvent.success).toBe(false, 'First build should not succeed.');
-              expect(logger.includes(staticAnalysisError)).toBe(true,
+              expect(logs.join().includes(staticAnalysisError)).toBe(true,
                 'First build should have static analysis error.');
-              logger.clear();
+              logs = [];
               // Fix the static analysis error.
               host.writeMultipleFiles({ 'src/app/app.component.ts': origContent });
               break;
 
             case 2:
               expect(buildEvent.success).toBe(true, 'Second build should succeed.');
-              expect(logger.includes(staticAnalysisError)).toBe(false,
+              expect(logs.join().includes(staticAnalysisError)).toBe(false,
                 'Second build should not have static analysis error.');
-              logger.clear();
+              logs = [];
               // Add an syntax error to a non-main file.
               host.appendToFile('src/app/app.component.ts', `]]]`);
               break;
 
             case 3:
               // The third build should have TS syntax error.
               expect(buildEvent.success).toBe(false, 'Third build should not succeed.');
-              expect(logger.includes(syntaxError)).toBe(true,
+              expect(logs.join().includes(syntaxError)).toBe(true,
                 'Third build should have syntax analysis error.');
-              expect(logger.includes(staticAnalysisError)).toBe(false,
+              expect(logs.join().includes(staticAnalysisError)).toBe(false,
                 'Third build should not have static analysis error.');
-              logger.clear();
+              logs = [];
               // Fix the syntax error, but add the static analysis error again.
               host.writeMultipleFiles({
                 'src/app/app.component.ts': origContent.replace(
@@ -402,21 +406,21 @@ describe('Browser Builder rebuilds', () => {
 
             case 4:
               expect(buildEvent.success).toBe(false, 'Fourth build should not succeed.');
-              expect(logger.includes(syntaxError)).toBe(false,
+              expect(logs.join().includes(syntaxError)).toBe(false,
                 'Fourth build should not have syntax analysis error.');
-              expect(logger.includes(staticAnalysisError)).toBe(true,
+              expect(logs.join().includes(staticAnalysisError)).toBe(true,
                 'Fourth build should have static analysis error.');
-              logger.clear();
+              logs = [];
               // Restore the file to a error-less state.
               host.writeMultipleFiles({ 'src/app/app.component.ts': origContent });
               break;
 
             case 5:
               // The fifth build should have everything fixed..
               expect(buildEvent.success).toBe(true, 'Fifth build should succeed.');
-              expect(logger.includes(syntaxError)).toBe(false,
+              expect(logs.join().includes(syntaxError)).toBe(false,
                 'Fifth build should not have syntax analysis error.');
-              expect(logger.includes(staticAnalysisError)).toBe(false,
+              expect(logs.join().includes(staticAnalysisError)).toBe(false,
                 'Fifth build should not have static analysis error.');
               break;
           }

packages/angular_devkit/build_angular/src/browser/specs/rebuild_spec.ts

@@ -7,8 +7,7 @@
  */
 
 import { Architect } from '@angular-devkit/architect';
-import { TestLogger } from '@angular-devkit/architect/testing';
-import { normalize, virtualFs } from '@angular-devkit/core';
+import { logging, normalize, virtualFs } from '@angular-devkit/core';
 import { of, race } from 'rxjs';
 import { delay, filter, map, take, takeUntil, takeWhile, tap, timeout } from 'rxjs/operators';
 import { browserBuild, createArchitect, host } from '../../test-utils';
@@ -179,7 +178,8 @@ describe('Browser Builder file replacements', () => {
 
     const unexpectedError = `Property 'two' does not exist on type '{ one: number; }'`;
     const expectedError = `Property 'prop' does not exist on type '{}'`;
-    const logger = new TestLogger('rebuild-type-errors');
+
+    const logger = new logging.Logger('');
 
     // Race between a timeout and the expected log entry.
     const stop$ = race<null | string>(