test: avoid test fixture affecting zone in all web tests (angular#46511)

We have a file called `test-events.js` (named in an ambiguous way
anyway) that runs for all Karma web tests and configures ZoneJS to
not patch the `scroll` event. There are two issues:

1. The patch applies to all web tests. This could cause unexpected
   issues.
2. The file is named ambiguously and also is placed at the project root,
   in a wrong spot.

Additionally, the test doesn't even fail when the file is removed. This
commit applies the Zone config locally to the closest build target and
also reworks the test to actually ensure it's testing what it describes.

PR Close angular#46511

Author: devversion

BUILD.bazel

@@ -25,7 +25,6 @@ filegroup(
         "//packages/zone.js/bundles:zone.umd.js",
         "//packages/zone.js/bundles:zone-testing.umd.js",
         "//packages/zone.js/bundles:task-tracking.umd.js",
-        "//:test-events.js",
         # Including systemjs because it defines `__eval`, which produces correct stack traces.
         "@npm//:node_modules/systemjs/dist/system.src.js",
         "@npm//:node_modules/reflect-metadata/Reflect.js",

karma-js.conf.js

@@ -36,6 +36,10 @@ module.exports = function(config) {
       'node_modules/core-js-bundle/index.js',
       'node_modules/jasmine-ajax/lib/mock-ajax.js',
 
+      // ZoneJS configuration needed for some event manager tests. This config could
+      // affect all legacy tests but in reality is scoped to certain special tests.
+      'packages/platform-browser/test/dom/events/zone_event_unpatched_init.js',
+
       // Dependencies built by Bazel. See `config.yml` for steps running before
       // the legacy Saucelabs tests run.
       'dist/bin/packages/zone.js/npm_package/bundles/zone.umd.js',

packages/platform-browser/test/BUILD.bazel

@@ -50,6 +50,10 @@ jasmine_node_test(
 
 karma_web_test_suite(
     name = "test_web",
+    bootstrap = [
+        "dom/events/zone_event_unpatched_init.js",
+        "//:web_test_bootstrap_scripts",
+    ],
     static_files = [
         ":static_assets/test.html",
     ],

packages/platform-browser/test/dom/events/event_manager_spec.ts

@@ -10,6 +10,7 @@ import {ɵgetDOM as getDOM} from '@angular/common';
 import {NgZone} from '@angular/core/src/zone/ng_zone';
 import {DomEventsPlugin} from '@angular/platform-browser/src/dom/events/dom_events';
 import {EventManager, EventManagerPlugin} from '@angular/platform-browser/src/dom/events/event_manager';
+
 import {createMouseEvent, el} from '../../../testing/src/browser_util';
 
 (function() {
@@ -310,28 +311,35 @@ describe('EventManager', () => {
     expect(receivedEvents).toEqual([]);
   });
 
+  // This test is reliant on `zone_event_unpatched_init.js` and verifies
+  // that the Zone unpatched event setting applies to the event manager.
   it('should run unpatchedEvents handler outside of ngZone', () => {
-    const Zone = (window as any)['Zone'];
     const element = el('<div><div></div></div>');
+    const zone = new NgZone({enableLongStackTrace: true});
+    const manager = new EventManager([domEventPlugin], zone);
+    let timeoutId: NodeJS.Timeout|null = null;
+
     doc.body.appendChild(element);
-    const dispatchedEvent = createMouseEvent('scroll');
-    let receivedEvent: any /** TODO #9100 */ = null;
-    let receivedZone: any = null;
-    const handler = (e: any /** TODO #9100 */) => {
-      receivedEvent = e;
-      receivedZone = Zone.current;
-    };
-    const manager = new EventManager([domEventPlugin], new FakeNgZone());
 
-    let remover = manager.addEventListener(element, 'scroll', handler);
-    getDOM().dispatchEvent(element, dispatchedEvent);
-    expect(receivedEvent).toBe(dispatchedEvent);
-    expect(receivedZone.name).not.toEqual('angular');
+    // Register the event listener in the Angular zone. If the handler would be
+    // patched then, the Zone should propagate into the listener callback.
+    zone.run(() => {
+      manager.addEventListener(element, 'unpatchedEventManagerTest', () => {
+        // schedule some timer that would cause the zone to become unstable. if the event
+        // handler would be patched, `hasPendingMacrotasks` would be `true`.
+        timeoutId = setTimeout(() => {}, 9999999);
+      });
+    });
 
-    receivedEvent = null;
-    remover && remover();
-    getDOM().dispatchEvent(element, dispatchedEvent);
-    expect(receivedEvent).toBe(null);
+    expect(zone.hasPendingMacrotasks).toBe(false);
+    getDOM().dispatchEvent(element, createMouseEvent('unpatchedEventManagerTest'));
+
+    expect(zone.hasPendingMacrotasks).toBe(false);
+    expect(timeoutId).not.toBe(null);
+
+    // cleanup the DOM by removing the test element we attached earlier.
+    doc.body.removeChild(element);
+    timeoutId && clearTimeout(timeoutId);
   });
 
   it('should only trigger one Change detection when bubbling with shouldCoalesceEventChangeDetection = true',

packages/platform-browser/test/dom/events/zone_event_unpatched_init.js

@@ -0,0 +1,17 @@
+/**
+ * @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
+ */
+
+// NOTE: This file affects most of tests in `platform-browser/test`. Make sure to
+// not change semantics of Angular that would result in false-positives. If you need
+// to change semantics of Angular, please create a separate test BUILD target.
+
+// This file marks the `unpatchedEventManagerTest` event as unpatched. This is not
+// strictly needed, but done for a specific test verifying that unpatched events are
+// running outside the zone. See `event_manager_spec.ts` and the
+// `unpatchedEvents handler outside of ngZone` spec.
+window.__zone_symbol__UNPATCHED_EVENTS = ['unpatchedEventManagerTest'];

packages/zone.js/lib/common/events.ts

@@ -396,7 +396,7 @@ export function patchEventTarget(
         const options = buildEventListenerOptions(arguments[2], passive);
 
         if (unpatchedEvents) {
-          // check upatched list
+          // check unpatched list
           for (let i = 0; i < unpatchedEvents.length; i++) {
             if (eventName === unpatchedEvents[i]) {
               if (passive) {