feat(@angular/cli): option to build and test only specified spec files

Author: FDIM

packages/angular_devkit/build_angular/src/angular-cli-files/plugins/karma.ts

@@ -14,6 +14,7 @@ import * as webpack from 'webpack';
 const webpackDevMiddleware = require('webpack-dev-middleware');
 
 import { KarmaWebpackFailureCb } from './karma-webpack-failure-cb';
+import { NormalizedKarmaBuilderSchema } from '../../karma/schema';
 import { statsErrorsToString } from '../utilities/stats';
 import { getWebpackStatsConfig } from '../models/webpack-configs/stats';
 import { createConsoleLogger } from '@angular-devkit/core/node';
@@ -63,7 +64,7 @@ const init: any = (config: any, emitter: any, customFileHandlers: any) => {
     ` be used from within Angular CLI and will not work correctly outside of it.`
     )
   }
-  const options = config.buildWebpack.options;
+  const options = config.buildWebpack.options as NormalizedKarmaBuilderSchema;
   const logger: logging.Logger = config.buildWebpack.logger || createConsoleLogger();
   successCb = config.buildWebpack.successCb;
   failureCb = config.buildWebpack.failureCb;

packages/angular_devkit/build_angular/src/karma/index.ts

@@ -14,6 +14,7 @@ import {
 } from '@angular-devkit/architect';
 import { Path, getSystemPath, normalize, resolve, virtualFs } from '@angular-devkit/core';
 import * as fs from 'fs';
+import * as glob from 'glob';
 import { Observable, of } from 'rxjs';
 import { concatMap } from 'rxjs/operators';
 import * as ts from 'typescript'; // tslint:disable-line:no-implicit-dependencies
@@ -76,12 +77,45 @@ export class KarmaBuilder implements Builder<KarmaBuilderSchema> {
         }
 
         const sourceRoot = builderConfig.sourceRoot && resolve(root, builderConfig.sourceRoot);
+        const webpackConfig = this.buildWebpackConfig(root, projectRoot, sourceRoot, host, options);
+
+        // generate new entry point with files matching provided glob
+        if (options.spec) {
+          const mainEntry = webpackConfig.entry.main;
+          const newMainEntry = webpackConfig.entry.main.replace(/\.ts$/, '.generated.ts');
+          // replace original entry with generated one
+          webpackConfig.entry.main = newMainEntry;
+
+          try {
+            this.createOrUpdateGeneratedTestFile(
+              options.spec,
+              getSystemPath(sourceRoot || projectRoot),
+              builderConfig.sourceRoot,
+              mainEntry,
+              newMainEntry,
+            );
+
+            // early exit if we are only supposed to update generated file
+            if (options.specUpdate) {
+              obs.next({ success: true, result: 'specs updated' });
+              obs.complete();
+
+              return;
+            }
+          } catch (err) {
+            this.context.logger.error(err.message);
+            obs.next({ success: false });
+            obs.complete();
+
+            return;
+          }
+        }
 
         karmaOptions.buildWebpack = {
           root: getSystemPath(root),
           projectRoot: getSystemPath(projectRoot),
           options,
-          webpackConfig: this.buildWebpackConfig(root, projectRoot, sourceRoot, host, options),
+          webpackConfig,
           // Pass onto Karma to emit BuildEvents.
           successCb: () => obs.next({ success: true }),
           failureCb: () => obs.next({ success: false }),
@@ -160,6 +194,45 @@ export class KarmaBuilder implements Builder<KarmaBuilderSchema> {
 
     return webpackMerge(webpackConfigs);
   }
+
+  createOrUpdateGeneratedTestFile(
+    pattern: string,
+    path: string,
+    sourceRoot: Path | undefined,
+    mainEntry: string,
+    newMainEntry: string,
+  ) {
+    let template = fs.readFileSync(mainEntry).toString();
+    // remove source root to support absolute paths
+    if (sourceRoot && pattern.startsWith(sourceRoot + '/')) {
+      pattern = pattern.substr(sourceRoot.length + 1); // +1 to include slash
+    }
+    if (pattern.endsWith('.ts') && pattern.indexOf('.spec.ts') === -1) {
+      pattern = pattern.substr(0, pattern.length - 2) + 'spec.ts';
+    } else if (pattern.indexOf('.spec') === -1) {
+      pattern += '.spec.ts';
+    }
+
+    const files = glob.sync(pattern, { cwd: path });
+    if (!files.length) {
+      throw new Error('Specified spec glob does not match any files');
+    }
+
+    const start = 'import \'';
+    const end = '\';';
+    const testCode = start + files
+      .map(path => `./${path.replace('.ts', '')}`)
+      .join(`${end}\n${start}`) + end;
+    // TODO: maybe a documented 'marker/comment' inside test.ts would be nicer
+    // or run typescript compiler and make changes based on the tree?
+    let mockedRequireContext = '{ keys: () => ({ map: (_a: any) => { } }) };';
+    mockedRequireContext += process.platform === 'win32' ? '\r\n' : '\n';
+    template = template
+      .replace(/declare\s+const\s+require:\s+any;/, '')
+      .replace(/require\.context\(.*/, mockedRequireContext + testCode);
+
+    fs.writeFileSync(newMainEntry, template);
+  }
 }
 
 export default KarmaBuilder;

packages/angular_devkit/build_angular/src/karma/schema.d.ts

@@ -40,6 +40,16 @@ export interface KarmaBuilderSchema extends Pick<BrowserBuilderSchema,
    * Karma reporters to use. Directly passed to the karma runner.
    */
   reporters?: string[];
+
+  /**
+   * Glob of files to include
+   */
+  spec?: string;
+
+  /**
+   * Should this only update generated test file?
+   */
+  specUpdate?: boolean;
 }
 
 export type KarmaSourceMapOptions = boolean | KarmaSourceMapObject;

packages/angular_devkit/build_angular/src/karma/schema.json

@@ -62,6 +62,15 @@
       "type": "string",
       "description": "Defines the build environment."
     },
+    "spec": {
+      "type": "string",
+      "description": "Glob of files to include"
+    },
+    "specUpdate": {
+      "type": "boolean",
+      "description": "Should this only update generated test file?",
+      "default": false
+    },
     "sourceMap": {
       "description": "Output sourcemaps.",
       "default": true,

packages/angular_devkit/build_angular/test/karma/selected_spec.ts

@@ -0,0 +1,87 @@
+/**
+ * @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 { DefaultTimeout, runTargetSpec } from '@angular-devkit/architect/testing';
+import { logging, normalize, virtualFs } from '@angular-devkit/core';
+import { tap } from 'rxjs/operators';
+import { NormalizedKarmaBuilderSchema } from '../../src';
+import { host, karmaTargetSpec } from '../utils';
+
+describe('Karma Builder', () => {
+  beforeEach(done => host.initialize().toPromise().then(done, done.fail));
+  afterEach(done => host.restore().toPromise().then(done, done.fail));
+
+  it('should fail spec option doesn\'t match any files', async (done) => {
+    const overrides: Partial<NormalizedKarmaBuilderSchema> = { spec: '---404' };
+    const logger = new logging.Logger('test');
+    const loggerSpy = jasmine.createSpy();
+    logger.subscribe(loggerSpy);
+    runTargetSpec(host, karmaTargetSpec, overrides, DefaultTimeout, logger).pipe(
+      tap((buildEvent) => {
+        expect(buildEvent.success).toBe(false, 'build failed');
+        expect(loggerSpy).toHaveBeenCalledWith(jasmine.objectContaining({
+          message: 'Specified spec glob does not match any files',
+        }));
+      }),
+    ).toPromise().then(done, done.fail);
+  }, 30000);
+
+  describe('selected tests', () => {
+    beforeEach(() => {
+      host.writeMultipleFiles({
+        'src/app/test.service.spec.ts': `
+          describe('TestService', () => {
+            it('should succeed', () => {
+              expect(true).toBe(true);
+            });
+          });`,
+        'src/app/failing.service.spec.ts': `
+          describe('FailingService', () => {
+            it('should be ignored', () => {
+              expect(true).toBe(false);
+            });
+          });`,
+      });
+    });
+    [
+      { message: 'absolute path to spec', path: 'src/app/test.service.spec.ts' },
+      { message: 'relative path from root to spec', path: 'app/test.service.spec.ts' },
+      { message: 'glob without spec suffix', path: '**/test.service' },
+      { message: 'glob with spec suffix', path: '**/test.service.spec.ts' },
+    ].forEach((options) => {
+
+      it('should work with ' + options.message, (done) => {
+        const overrides: Partial<NormalizedKarmaBuilderSchema> = { spec: options.path };
+        runTargetSpec(host, karmaTargetSpec, overrides).pipe(
+          tap((buildEvent) => {
+            expect(buildEvent.success).toBe(true, 'build failed');
+          }),
+        ).toPromise().then(done, done.fail);
+      }, 30000);
+    });
+  });
+
+  it('should only update generated file', (done) => {
+    const overrides: Partial<NormalizedKarmaBuilderSchema> = {
+      spec: '**/app.component.spec.ts',
+      specUpdate: true,
+    };
+    const newEntryPoint = normalize('src/test.generated.ts');
+    runTargetSpec(host, karmaTargetSpec, overrides).pipe(
+      tap((buildEvent) => {
+        expect(buildEvent.success).toBe(true, 'build failed');
+        expect(buildEvent.result).toEqual('specs updated');
+
+        expect(host.scopedSync().exists(newEntryPoint)).toBe(true);
+        const content = virtualFs.fileBufferToString(host.scopedSync().read(newEntryPoint));
+        expect(content).toContain('import \'./app/app.component.spec\';');
+        expect(content).toContain('{ keys: () => ({ map: (_a: any) => { } }) }');
+      }),
+    ).toPromise().then(done, done.fail);
+  }, 30000);
+
+});

packages/schematics/angular/application/files/root/tsconfig.spec.json

@@ -12,6 +12,7 @@
     "<%= rootInSrc ? '' : 'src/' %>polyfills.ts"
   ],
   "include": [
+    "<%= rootInSrc ? '' : 'src/' %>test.generated.ts",
     "**/*.spec.ts",
     "**/*.d.ts"
   ]

packages/schematics/angular/library/files/__projectRoot__/tsconfig.spec.json

@@ -11,6 +11,7 @@
     "src/test.ts"
   ],
   "include": [
+    "src/test.generated.ts",
     "**/*.spec.ts",
     "**/*.d.ts"
   ]

packages/schematics/angular/workspace/files/__dot__gitignore

@@ -5,6 +5,9 @@
 /tmp
 /out-tsc
 
+# used to run specific tests instead of all
+test.generated.ts
+
 # dependencies
 /node_modules
 

tests/angular_devkit/build_angular/hello-world-app/src/tsconfig.spec.json

@@ -13,6 +13,7 @@
     "polyfills.ts"
   ],
   "include": [
+    "test.generated.ts",
     "**/*.spec.ts",
     "**/*.d.ts"
   ]

tests/angular_devkit/build_ng_packagr/ng-packaged/projects/lib/tsconfig.spec.json

@@ -11,6 +11,7 @@
     "src/test.ts"
   ],
   "include": [
+    "test.generated.ts",
     "**/*.spec.ts",
     "**/*.d.ts"
   ]