feat: add precompileForTests()

Author: ersimont

README.md

@@ -12,10 +12,10 @@ yarn add -D s-ng-dev-utils
 
 ## TSLint Config
 
-This library also comes with a predefined `tslint.json` that extends the angular cli's config to disable rules that conflict with Prettier (via [tslint-config-prettier](https://github.com/prettier/tslint-config-prettier)), with these exceptions that Simonton Software has found useful:
+This library also comes with a predefined `tslint.json` that extends the angular cli's config to disable rules that conflict with Prettier (via [tslint-config-prettier](https://github.com/prettier/tslint-config-prettier)), with these exceptions that we have found useful:
 
 - Allows using the `Function` type. Some of our libraries deal a lot with utilities that operate on functions, and using this type is very handy.
-- Allows prefixing variables with `_`. This is useful e.g. when overriding a method in a way that does not use all its parameters. Simonton Software uses typescript's "noUnusedParameters" option, which gives an error with unused parameters unless their names are prefixed with `_`.
+- Allows prefixing variables with `_`. This is useful e.g. when overriding a method in a way that does not use all its parameters. We uses typescript's "noUnusedParameters" option, which gives an error with unused parameters unless their names are prefixed with `_`.
 - Downgrades [no-non-null-assertion](https://palantir.github.io/tslint/rules/no-non-null-assertion/) to a warning. While we believe using `!` should be avoided when reasonable, we find that sometimes it just makes sense.
 
 To use it, change your `tslint.json` to:

projects/s-ng-dev-utils/src/lib/precompile-for-tests.spec.ts

@@ -0,0 +1,72 @@
+import { Component, Injectable, NgModule } from "@angular/core";
+import { TestBed } from "@angular/core/testing";
+import { precompileForTests } from "./precompile-for-tests";
+
+@Injectable({ providedIn: "root" })
+class ProvidedInRoot {
+  counter = 0;
+}
+
+@Injectable()
+class ProvidedInModule {
+  counter = 0;
+}
+
+@Injectable()
+class ProvidedInComponent {
+  counter = 0;
+}
+
+@Component({
+  template: "I exist! Created {{ providedInComponent.counter }} time(s).",
+  providers: [ProvidedInComponent],
+})
+class AComponent {
+  constructor(public providedInComponent: ProvidedInComponent) {
+    ++providedInComponent.counter;
+  }
+}
+
+@NgModule({ declarations: [AComponent], providers: [ProvidedInModule] })
+class AModule {}
+
+describe("precompileForTests()", () => {
+  precompileForTests([AModule]);
+
+  async function initFullModule() {
+    TestBed.configureTestingModule({ imports: [AModule] });
+    await TestBed.compileComponents();
+  }
+
+  /////////
+
+  it("allows components", async () => {
+    await initFullModule();
+    const fixture = TestBed.createComponent(AComponent);
+    expect(fixture.nativeElement.textContent).toContain("I exist!");
+  });
+
+  it("allows declaring only a component", async () => {
+    TestBed.configureTestingModule({ declarations: [AComponent] });
+    await TestBed.compileComponents();
+    const fixture = TestBed.createComponent(AComponent);
+    expect(fixture.nativeElement.textContent).toContain("I exist!");
+  });
+
+  for (let i = 0; i < 3; ++i) {
+    it(`allows clearing service state between tests, iteration ${i}`, async () => {
+      await initFullModule();
+      const providedInRoot = TestBed.get(ProvidedInRoot);
+      const providedInModule = TestBed.get(ProvidedInModule);
+      const fixture = TestBed.createComponent(AComponent);
+      fixture.detectChanges();
+
+      expect(providedInRoot.counter).toBe(0);
+      expect(providedInModule.counter).toBe(0);
+      expect(fixture.nativeElement.textContent).toContain("Created 1 time(s).");
+
+      ++providedInRoot.counter;
+      ++providedInModule.counter;
+    });
+  }
+});

projects/s-ng-dev-utils/src/lib/precompile-for-tests.ts

@@ -0,0 +1,87 @@
+import { CompileMetadataResolver } from "@angular/compiler";
+import { TestBed } from "@angular/core/testing";
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from "@angular/platform-browser-dynamic/testing";
+
+/**
+ * Use this to speed up your angular test suite. Normally when you call `TestBed.compileComponents()`, it recompiles all the configured components even if it has compiled them before in a previous test. AoT compilation would be a great fix, but is not well supported/documented for tests yet. This function fills the gap by precompiling the components as if by AoT and setting up `TestBed` to use them.
+ *
+ * ```ts
+ * // let's assume `AppModule` declares or imports a `HelloWorldComponent`
+ * precompileForTests([AppModule]);
+ *
+ * describe("AppComponent", () => {
+ *   it("says hello", async () => {
+ *     TestBed.configureTestingModule({ declarations: [HelloWorldComponent] });
+ *     await TestBed.compileComponents(); // <- this line is faster
+ *     const fixture = TestBed.createComponent(HelloWorldComponent);
+ *     expect(fixture.nativeElement.textContent).toContain("Hello, world!");
+ *   });
+ * });
+ * ```
+ *
+ * Note that this uses `TestBed.initTestEnvironment` to set up the precompiled components, so you will not be able to use it yourself at the same time.
+ */
+export function precompileForTests(modules: any[], skipModules: any[] = []) {
+  beforeAll(async () => {
+    TestBed.configureTestingModule({ imports: modules });
+    await TestBed.compileComponents();
+
+    // technique modeled from https://github.com/angular/angular/blob/11325bad4ab786a07e52ff380c00622fda11c0b7/packages/core/test/linker/jit_summaries_integration_spec.ts#L83
+    const metadataResolver = TestBed.get(
+      CompileMetadataResolver,
+    ) as CompileMetadataResolver;
+
+    TestBed.resetTestEnvironment();
+    TestBed.initTestEnvironment(
+      BrowserDynamicTestingModule,
+      platformBrowserDynamicTesting(),
+      () =>
+        extractAotSummaries(metadataResolver, modules, new Set(skipModules)),
+    );
+  });
+}
+
+function extractAotSummaries(
+  metadataResolver: CompileMetadataResolver,
+  modules: any[],
+  skipModules: Set<any>,
+): any[] {
+  return modules.map((module) => () =>
+    extractAotSummaries0(metadataResolver, module, skipModules),
+  );
+}
+
+function extractAotSummaries0(
+  metadataResolver: CompileMetadataResolver,
+  module: any,
+  skipModules: Set<any>,
+) {
+  if (skipModules.has(module)) {
+    return [];
+  }
+  skipModules.add(module);
+
+  const moduleMetadata = metadataResolver.getNgModuleMetadata(module)!;
+  return [
+    metadataResolver.getNgModuleSummary(module),
+    () =>
+      moduleMetadata.declaredDirectives.map((directive) =>
+        metadataResolver.getDirectiveSummary(directive.reference),
+      ),
+    () =>
+      moduleMetadata.declaredPipes.map((pipe) =>
+        metadataResolver.getPipeSummary(pipe.reference),
+      ),
+    () =>
+      extractAotSummaries(
+        metadataResolver,
+        moduleMetadata.importedModules.map(
+          (importedModule) => importedModule.type.reference,
+        ),
+        skipModules,
+      ),
+  ];
+}

projects/s-ng-dev-utils/src/public-api.ts

@@ -6,3 +6,4 @@ export { expectCallsAndReset } from "./lib/expect-calls-and-reset";
 export { expectSingleCallAndReset } from "./lib/expect-single-call-and-reset";
 export { expectType } from "./lib/expect-type";
 export { marbleTest } from "./lib/marble-test";
+export { precompileForTests } from "./lib/precompile-for-tests";