Revert "build: delete unused benchmark tests which do not build (#25384)"

This reverts commit 79a96c1.

Author: wagnermaciel

test/BUILD.bazel

@@ -0,0 +1,18 @@
+load("//tools:defaults.bzl", "ts_library")
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files(["bazel-karma-local-config.js"])
+
+# Common set-up for all Angular Material and CDK tests.
+ts_library(
+    name = "angular_test_init",
+    testonly = True,
+    # This file *must* end with "spec" in order for "karma_web_test_suite" to load it.
+    srcs = ["angular-test-init-spec.ts"],
+    deps = [
+        "@npm//@angular/core",
+        "@npm//@angular/platform-browser-dynamic",
+        "@npm//@types/jasmine",
+    ],
+)

test/angular-test-init-spec.ts

@@ -0,0 +1,16 @@
+import {TestBed} from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+
+/*
+ * Common setup / initialization for all unit tests in Angular Material and CDK.
+ */
+
+TestBed.initTestEnvironment([BrowserDynamicTestingModule], platformBrowserDynamicTesting());
+
+(window as any).module = {};
+(window as any).isNode = false;
+(window as any).isBrowser = true;
+(window as any).global = window;

test/bazel-karma-local-config.js

@@ -0,0 +1,46 @@
+/**
+ * Karma configuration that is used by Bazel karma_web_test targets which do not
+ * want to launch any browser and just enable manual browser debugging.
+ */
+
+module.exports = config => {
+  const overwrites = {};
+
+  // By default "@bazel/concatjs" configures Chrome as browser. Since we don't want
+  // to launch any browser at all, we overwrite the "browsers" option. Since the
+  // default config tries to extend the browsers array with "Chrome", we need to
+  // always return a new empty array.
+  Object.defineProperty(overwrites, 'browsers', {
+    get: () => [],
+    set: () => {},
+    enumerable: true,
+  });
+
+  // Ensures that tests start executing once browsers have been manually connected. We need
+  // to use "defineProperty" because the default "@bazel/concatjs" config overwrites the option.
+  Object.defineProperty(overwrites, 'autoWatch', {
+    get: () => true,
+    set: () => {},
+    enumerable: true,
+  });
+
+  // When not running with ibazel, do not set up the `@bazel/concatjs` watcher. This one
+  // relies on ibazel to write to the `stdin` interface. When running without ibazel, the
+  // watcher will kill concatjs since there is no data written to the `stdin` interface.
+  if (process.env['IBAZEL_NOTIFY_CHANGES'] !== 'y') {
+    // We pre-define a plugins array that captures registration of Karma plugins
+    // and unsets the watcher definitions so that no watcher can be configured.
+    overwrites.plugins = new KarmaPluginArrayWithoutWatchers();
+  }
+
+  config.set(overwrites);
+};
+
+class KarmaPluginArrayWithoutWatchers extends Array {
+  // The Bazel Karma rules only register new plugins using `.push`.
+  push(...plugins) {
+    plugins.filter(p => typeof p === 'object').forEach(p => delete p.watcher);
+
+    super.push(...plugins);
+  }
+}

test/benchmarks/cdk/testing/component-harness/BUILD.bazel

@@ -0,0 +1,79 @@
+load("@npm//@angular/build-toolinge/bazel/benchmark/component_benchmark:component_benchmark.bzl", "component_benchmark")
+load("//tools:defaults.bzl", "ng_test_library", "ng_web_test_suite", "ts_library")
+
+package(default_visibility = ["//visibility:public"])
+
+# These are two separate files that provide the same tidy interface for running a performance
+# benchmark.
+#
+# The testbed and protractor tests use different methods for measuring time. Since Karma does not
+# patch console.time, the results are not pushed back from the page to the Karma server. Instead
+# we use performance.now() to measure performance.
+
+ts_library(
+    name = "constants",
+    srcs = [":constants.ts"],
+)
+
+ts_library(
+    name = "protractor-benchmark-utilities",
+    srcs = [":protractor-benchmark-utilities.ts"],
+    deps = [
+        ":constants",
+        "@npm//@angular/build-tooling/bazel/benchmark/driver-utilities",
+        "@npm//@types/node",
+    ],
+)
+
+ts_library(
+    name = "testbed-benchmark-utilities",
+    srcs = [":testbed-benchmark-utilities.ts"],
+    deps = [":constants"],
+)
+
+# ProtractorHarnessEnvironment
+
+component_benchmark(
+    name = "e2e_benchmark",
+    driver = ":protractor.perf-spec.ts",
+    driver_deps = [
+        ":constants",
+        ":protractor-benchmark-utilities",
+        "@npm//protractor",
+        "@npm//@types/jasmine",
+        "@npm//@types/node",
+        "//src/cdk/testing",
+        "//src/material/button/testing",
+        "//src/cdk/testing/protractor",
+    ],
+    ng_deps = [
+        ":constants",
+        "@npm//@angular/core",
+        "@npm//@angular/platform-browser",
+        "//src/material/button",
+    ],
+    ng_srcs = [":app.module.ts"],
+    prefix = "",
+    styles = ["//src/material/prebuilt-themes:indigo-pink"],
+)
+
+# TestbedHarnessEnvironment
+
+ng_test_library(
+    name = "unit_tests_lib",
+    srcs = ["testbed.perf-spec.ts"],
+    deps = [
+        ":constants",
+        ":testbed-benchmark-utilities",
+        "//src/cdk/testing",
+        "//src/cdk/testing/testbed",
+        "//src/material/button",
+        "//src/material/button/testing",
+        "@npm//@angular/build-tooling/bazel/benchmark/driver-utilities",
+    ],
+)
+
+ng_web_test_suite(
+    name = "unit_benchmark_tests",
+    deps = [":unit_tests_lib"],
+)

test/benchmarks/cdk/testing/component-harness/app.module.ts

@@ -0,0 +1,33 @@
+/**
+ * @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 {Component, NgModule, ViewEncapsulation} from '@angular/core';
+import {BrowserModule} from '@angular/platform-browser';
+import {MatButtonModule} from '@angular/material/button';
+import {NUM_BUTTONS} from './constants';
+
+/** component: component-harness-test */
+
+@Component({
+  selector: 'app-root',
+  template: `
+    <button *ngFor="let val of vals" mat-button> {{ val }} </button>
+  `,
+  encapsulation: ViewEncapsulation.None,
+  styleUrls: ['../../../../../src/material/core/theming/prebuilt/indigo-pink.css'],
+})
+export class ButtonHarnessTest {
+  vals = Array.from({length: NUM_BUTTONS}, (_, i) => i);
+}
+
+@NgModule({
+  declarations: [ButtonHarnessTest],
+  imports: [BrowserModule, MatButtonModule],
+  bootstrap: [ButtonHarnessTest],
+})
+export class AppModule {}

test/benchmarks/cdk/testing/component-harness/constants.ts

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+
+/**
+ * Benchpress gives us fine-grained metrics on browser interactions. In some cases, we want to
+ * just get a whole measurement of how long the entire interaction took.
+ */
+export const USE_BENCHPRESS = false;
+
+export const NUM_BUTTONS = 25;
+export const MIDDLE_BUTTON = `${Math.floor(NUM_BUTTONS / 2)}`;

test/benchmarks/cdk/testing/component-harness/protractor-benchmark-utilities.ts

@@ -0,0 +1,48 @@
+/**
+ * @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 {runBenchmark} from '@angular/build-tooling/bazel/benchmark/driver-utilities';
+import {USE_BENCHPRESS} from './constants';
+
+/**
+ * Records the performance of the given function.
+ *
+ * @param id A unique identifier.
+ * @param callback A function whose performance will be recorded.
+ */
+export async function benchmark(id: string, callback: () => Promise<unknown>) {
+  if (USE_BENCHPRESS) {
+    await benchmarkWithBenchpress(id, callback);
+  } else {
+    await benchmarkWithConsoleAPI(id, callback);
+  }
+}
+
+/**
+ * A simple wrapper for runBenchmark which is a wrapper for benchpress.
+ */
+async function benchmarkWithBenchpress(id: string, callback: () => Promise<unknown>) {
+  await runBenchmark({
+    id,
+    url: '',
+    ignoreBrowserSynchronization: true,
+    work: async () => await callback(),
+  });
+}
+
+/**
+ * Measures the time it takes to invoke the given function and prints the duration to the console.
+ */
+async function benchmarkWithConsoleAPI(id: string, callback: () => Promise<unknown>, runs = 5) {
+  const t0 = Number(process.hrtime.bigint()) / 1000000;
+  for (let i = 0; i < runs; i++) {
+    await callback();
+  }
+  const t1 = Number(process.hrtime.bigint()) / 1000000;
+  console.warn(`${id}: ${((t1 - t0) / runs).toFixed(2)}ms (avg over ${runs} runs)`);
+}

test/benchmarks/cdk/testing/component-harness/protractor.perf-spec.ts

@@ -0,0 +1,101 @@
+/**
+ * @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 {HarnessLoader} from '@angular/cdk/testing';
+import {MatButtonHarness} from '@angular/material/button/testing/button-harness';
+import {ProtractorHarnessEnvironment} from '@angular/cdk/testing/protractor';
+import {$$, element, by, browser} from 'protractor';
+import {benchmark} from './protractor-benchmark-utilities';
+import {NUM_BUTTONS} from './constants';
+
+const FIRST_BUTTON = '0';
+const MIDDLE_BUTTON = `${Math.floor(NUM_BUTTONS / 2)}`;
+const LAST_BUTTON = `${NUM_BUTTONS - 1}`;
+
+describe('baseline tests for interacting with the page through Protractor directly', () => {
+  beforeEach(async () => {
+    await browser.get('');
+  });
+
+  it('(baseline) should retrieve all of the buttons', async () => {
+    await benchmark('(baseline) get every button', async () => {
+      await $$('.mat-button');
+    });
+  });
+
+  it('(baseline) should click the first button', async () => {
+    await benchmark('(baseline) click first button', async () => {
+      await element(by.buttonText(FIRST_BUTTON)).click();
+    });
+  });
+
+  it('(baseline) should click the middle button', async () => {
+    await benchmark('(baseline) click middle button', async () => {
+      await element(by.buttonText(MIDDLE_BUTTON)).click();
+    });
+  });
+
+  it('(baseline) should click the last button', async () => {
+    await benchmark('(baseline) click last button', async () => {
+      await element(by.buttonText(LAST_BUTTON)).click();
+    });
+  });
+
+  it('(baseline) should click all of the buttons', async () => {
+    await benchmark('(baseline) click every button', async () => {
+      const buttons = $$('.mat-button');
+      await buttons.each(async button => await button!.click());
+    });
+  });
+});
+
+describe('performance tests for the protractor button harness', () => {
+  let loader: HarnessLoader;
+
+  beforeEach(async () => {
+    await browser.get('');
+    loader = ProtractorHarnessEnvironment.loader();
+  });
+
+  it('should retrieve all of the buttons', async () => {
+    await benchmark('get every button', async () => {
+      await loader.getAllHarnesses(MatButtonHarness);
+    });
+  });
+
+  it('should click the first button', async () => {
+    await benchmark('click first button', async () => {
+      const button = await loader.getHarness(MatButtonHarness.with({text: FIRST_BUTTON}));
+      await button.click();
+    });
+  });
+
+  it('should click the middle button', async () => {
+    await benchmark('click middle button', async () => {
+      const button = await loader.getHarness(MatButtonHarness.with({text: MIDDLE_BUTTON}));
+      await button.click();
+    });
+  });
+
+  it('should click the last button', async () => {
+    await benchmark('click last button', async () => {
+      const button = await loader.getHarness(MatButtonHarness.with({text: LAST_BUTTON}));
+      await button.click();
+    });
+  });
+
+  it('should click all of the buttons', async () => {
+    await benchmark('click every button', async () => {
+      const buttons = await loader.getAllHarnesses(MatButtonHarness);
+      for (let i = 0; i < buttons.length; i++) {
+        const button = buttons[i];
+        await button.click();
+      }
+    });
+  });
+});

test/benchmarks/cdk/testing/component-harness/testbed-benchmark-utilities.ts

@@ -0,0 +1,24 @@
+/**
+ * @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
+ */
+
+/**
+ * Measures the time it takes to invoke the given function and prints the duration to the console.
+ * @param id A unique identifier for the callback being measured.
+ * @param callback A function whose performance will be recorded.
+ * @param runs The number of times to run the callback.
+ */
+export async function benchmark(id: string, callback: () => Promise<unknown>, runs = 5) {
+  // Currently karma does not send the logs from console.time to the server so console.time will
+  // not show. As an alternative, we use performance.now()
+  const t0 = performance.now();
+  for (let i = 0; i < runs; i++) {
+    await callback();
+  }
+  const t1 = performance.now();
+  console.warn(`${id}: ${((t1 - t0) / runs).toFixed(2)}ms (avg over ${runs} runs)`);
+}