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

Author: FDIM

packages/angular_devkit/build_angular/src/angular-cli-files/plugins/single-test-transform.ts

@@ -0,0 +1,31 @@
+/**
+ * @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 { logging } from '@angular-devkit/core';
+import { getOptions } from 'loader-utils';
+import { loader } from 'webpack';
+
+export interface SingleTestTransformLoaderOptions {
+  files: string[];
+  logger: logging.Logger;
+}
+
+export default function loader(this: loader.LoaderContext, source: string) {
+  const options = getOptions(this) as SingleTestTransformLoaderOptions;
+  const start = 'import \'';
+  const end = '\';';
+  const testCode = start + options.files
+    .map(path => `./${path.replace('.ts', '')}`)
+    .join(`${end}\n${start}`) + end;
+
+  // TODO: maybe a documented 'marker/comment' inside test.ts would be nicer?
+  let mockedRequireContext = '{ keys: () => ({ map: (_a) => { } }) };';
+  mockedRequireContext += process.platform === 'win32' ? '\r\n' : '\n';
+  source = source.replace(/require\.context\(.*/, mockedRequireContext + testCode);
+
+  return source;
+}

packages/angular_devkit/build_angular/src/angular-cli-files/utilities/find-specs.ts

@@ -0,0 +1,31 @@
+/**
+ * @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 { Path, getSystemPath, join } from '@angular-devkit/core';
+import * as glob from 'glob';
+
+export function findSpecs(input: string, workspaceRoot: Path, sourceRoot: string): string[] {
+
+  input = input.replace(/\\/g, '/'); // normalize input
+
+  // remove source root to support relative paths from root
+  // such paths are easy to get when running script via IDEs
+  if (sourceRoot && input.startsWith(sourceRoot + '/')) {
+    input = input.substr(sourceRoot.length + 1); // +1 to include slash
+  }
+
+  if (input.endsWith('.ts') && !input.endsWith('.spec.ts')) {
+    input = input.substr(0, input.length - 2) + 'spec.ts';
+  } else if (!input.endsWith('.spec.ts') && input.indexOf('*') === -1) {
+    input += '**/*.spec.ts';
+  }
+  const files = glob.sync(input, {
+    cwd: getSystemPath(join(workspaceRoot, sourceRoot)),
+  });
+
+  return files;
+}

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

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';
+import { experimental } from '@angular-devkit/core';
 import { resolve } from 'path';
 import { Observable, from } from 'rxjs';
 import { switchMap } from 'rxjs/operators';
@@ -17,6 +18,10 @@ import {
   getTestConfig,
   getWorkerConfig,
 } from '../angular-cli-files/models/webpack-configs';
+import {
+  SingleTestTransformLoaderOptions,
+} from '../angular-cli-files/plugins/single-test-transform';
+import { findSpecs } from '../angular-cli-files/utilities/find-specs';
 import { Schema as BrowserBuilderOptions } from '../browser/schema';
 import { ExecutionTransformer } from '../transforms';
 import { Version } from '../utils/version';
@@ -33,9 +38,13 @@ async function initialize(
   options: KarmaBuilderOptions,
   context: BuilderContext,
   webpackConfigurationTransformer?: ExecutionTransformer<webpack.Configuration>,
+): Promise<[
+  experimental.workspace.Workspace,
+  string,
   // tslint:disable-next-line:no-implicit-dependencies
-): Promise<[typeof import ('karma'), webpack.Configuration]> {
-  const { config } = await generateBrowserWebpackConfigFromContext(
+  typeof import ('karma'), webpack.Configuration
+]> {
+  const { config, workspace, projectName } = await generateBrowserWebpackConfigFromContext(
     // only two properties are missing:
     // * `outputPath` which is fixed for tests
     // * `budgets` which might be incorrect due to extra dev libs
@@ -54,6 +63,8 @@ async function initialize(
   const karma = await import('karma');
 
   return [
+    workspace,
+    projectName,
     karma,
     webpackConfigurationTransformer ? await webpackConfigurationTransformer(config[0]) : config[0],
   ];
@@ -72,7 +83,12 @@ export function execute(
   Version.assertCompatibleAngularVersion(context.workspaceRoot);
 
   return from(initialize(options, context, transforms.webpackConfiguration)).pipe(
-    switchMap(([karma, webpackConfig]) => new Observable<BuilderOutput>(subscriber => {
+    switchMap(([
+      workspace,
+      projectName,
+      karma,
+      webpackConfig,
+    ]) => new Observable<BuilderOutput>(subscriber => {
       const karmaOptions: KarmaConfigOptions = {};
 
       if (options.watch !== undefined) {
@@ -95,6 +111,33 @@ export function execute(
         }
       }
 
+      // prepend special webpack loader that will transform test.ts
+      if (webpackConfig && webpackConfig.module && options.spec) {
+        const sourceRoot = workspace.getProject(projectName).sourceRoot || '';
+        const files = findSpecs(options.spec, workspace.root, sourceRoot);
+        // early exit, no reason to start karma
+        if (!files.length) {
+          subscriber.error(`Specified pattern: "${options.spec}" did not match any spec files`);
+
+          return;
+        }
+        // local unit test requires .ts extension
+        // without one specs will fail with unclear error
+        // release build does not need any extension
+        const ext = __filename.endsWith('.ts') ? '.ts' : '';
+
+        webpackConfig.module.rules.unshift({
+          test: /test\.ts$/,
+          use: {
+            loader: resolve(__dirname, '../angular-cli-files/plugins/single-test-transform' + ext),
+            options: {
+              files,
+              logger: context.logger,
+            } as SingleTestTransformLoaderOptions,
+          },
+        });
+      }
+
       // Assign additional karmaConfig options to the local ngapp config
       karmaOptions.configFile = resolve(context.workspaceRoot, options.karmaConfig);
 

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

@@ -63,6 +63,10 @@
       "type": "string",
       "description": "Defines the build environment."
     },
+    "spec": {
+      "type": "string",
+      "description": "Glob of files to include"
+    },
     "sourceMap": {
       "description": "Output sourcemaps.",
       "default": true,

packages/angular_devkit/build_angular/src/utils/webpack-browser-config.ts

@@ -169,7 +169,11 @@ export async function generateBrowserWebpackConfigFromContext(
   context: BuilderContext,
   webpackPartialGenerator: (wco: BrowserWebpackConfigOptions) => webpack.Configuration[],
   host: virtualFs.Host<fs.Stats> = new NodeJsSyncHost(),
-): Promise<{ workspace: experimental.workspace.Workspace, config: webpack.Configuration[] }> {
+): Promise<{
+  workspace: experimental.workspace.Workspace,
+  projectName: string,
+  config: webpack.Configuration[],
+ }> {
   const registry = new schema.CoreSchemaRegistry();
   registry.addPostTransform(schema.transforms.addUndefinedDefaults);
 
@@ -195,5 +199,5 @@ export async function generateBrowserWebpackConfigFromContext(
     context.logger,
   );
 
-  return { workspace, config };
+  return { workspace, projectName, config };
 }

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

@@ -0,0 +1,96 @@
+/**
+ * @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 { Architect } from '@angular-devkit/architect';
+import { createArchitect, host, karmaTargetSpec } from '../utils';
+
+describe('Karma Builder', () => {
+  let architect: Architect;
+
+  beforeEach(async () => {
+    await host.initialize().toPromise();
+    architect = (await createArchitect(host.root())).architect;
+  });
+
+  afterEach(() => host.restore().toPromise());
+
+  it('should fail when spec does not match any files', async () => {
+    const overrides = {
+      spec: 'abc.spec.ts',
+    };
+    const run = await architect.scheduleTarget(karmaTargetSpec, overrides);
+
+    await expectAsync(run.result)
+      .toBeRejectedWith(`Specified pattern: "abc.spec.ts" did not match any spec files`);
+
+    await run.stop();
+  });
+
+  describe('selected tests', () => {
+    beforeEach(() => {
+      host.writeMultipleFiles({
+        'src/app/services/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);
+            });
+          });`,
+        'src/app/property.pipe.spec.ts': `
+          describe('PropertyPipe', () => {
+            it('should succeed', () => {
+              expect(true).toBe(true);
+            });
+          });`,
+      });
+    });
+    [
+      {
+        test: 'relative path from workspace to spec',
+        input: 'src/app/app.component.spec.ts',
+      },
+      {
+        test: 'relative path from project root to spec',
+        input: 'app/services/test.service.spec.ts',
+      },
+      {
+        test: 'relative path from workspace to spec',
+        input: 'src/app/services',
+      },
+      {
+        test: 'relative path from project root to spec',
+        input: 'app/services',
+      },
+      {
+        test: 'glob with spec suffix',
+        input: '**/*.pipe.spec.ts',
+      },
+      {
+        test: 'glob to typescript file',
+        input: '**/app.component.ts',
+      },
+    ].forEach((options) => {
+
+      it(`should work with ${options.test}`, async () => {
+        const overrides = {
+          spec: options.input,
+        };
+        const run = await architect.scheduleTarget(karmaTargetSpec, overrides);
+
+        await expectAsync(run.result).toBeResolvedTo(jasmine.objectContaining({ success: true }));
+
+        await run.stop();
+      }, 30000);
+    });
+  });
+
+});