test(wtr): change jasmine globals to explicit imports @W-19098266 (#5490)

* test(wtr): update tests to use relative path to utils

instead of weird fake module

* test(wtr): revert removing TestUtils

* test(wtr): remove useless describe

There's no setup/teardown needed, it's a single test, and WTR provides per-file encapsulation

* test(wtr): replace IIFE script with module import

* test(wtr): clean up SSR execution script

working toward just importing and executing things, but not quite there yet

* test(wtr): always use DISABLE_SYNTHETIC

two env vars for the same goal is unnecessary

* test(wtr): enable all hydration tests

I think the last one was a concurrency related timeout,
which was previously addressed.

* test(wtr): remove side effect from signals helper

helper files shouldn't have side effects; all setup should be in the setup file

* test(wtr): import directly from file, not from barrel exporter

* test(wtr): change bulk export statement to individual exports

* test(wtr): remove unnecessary aria re-export

* test(wtr): fix a few more ARIA util imports

* chore: move comment for nicer aesthetic

* test(wtr): remove unused option

* test(wtr): fix another ARIA util import

* test(wtr): import directly from hooks file rather than utils

* test(wtr): import directly from signals file rather than utils

* test(wtr): import directly from console helper rather than utils

* test(wtr): import directly from constants helper rather than utils

* test(wtr): only import what is needed from LWC

* test(wtr): split lwc:dynamic load helpers into separate file

* test(wtr): avoid relying on global LWC

* test(wtr): remove unnecessary wrapping of hydration test config

* test(wtr): remove test-utils logic from resolveImport

no longer necessary

* test(wtr): move plugin from shared config to only config that uses it

* test(wtr): remove useless guid

all tests are run in isolation

* test(wtr): remove unnecessary test-utils global

* test(wtr): clean up component definition

* test(wtr): change component in test from IIFE to import

* test(wtr): shift logic out of wrapper into static test runner file

we want to keep the generated wrappers as thin as possible

and use regular js files as much as possible

* test(wtr): make test setup/teardown more idiomatic

* test(wtr): clean up module compilation

* chore(wtr): make dependency on @vitest/spy explicit

* test(wtr): remove console suppression

It was originally implemented to suppress distracting warnings in Karma tests,
but WTR's log output is different / managed differently.

* test(wtr): clean up names and comments

* test(wtr): move and rename file

* test(wtr): remove usage of global TestUtils from hydration tests

* test(wtr): remove LWC import from utils

It breaks hydration tests if there's an import from LWC.

* test(wtr): remove unused external deps

* test(wtr): use imports instead of jasmine globals

* chore(eslint): remove unused rule config

Author: wjhsf

eslint.config.mjs

@@ -362,14 +362,8 @@ export default tseslint.config(
                 lwcRuntimeFlags: true,
                 process: true,
                 ...globals.browser,
-                ...globals.jasmine,
             },
         },
-
-        rules: {
-            'no-var': 'off',
-            'prefer-rest-params': 'off',
-        },
     },
     {
         files: ['packages/@lwc/integration-karma/**'],
@@ -384,11 +378,6 @@ export default tseslint.config(
                 ...globals.jasmine,
             },
         },
-
-        rules: {
-            'no-var': 'off',
-            'prefer-rest-params': 'off',
-        },
     },
     {
         files: ['packages/@lwc/synthetic-shadow/**'],

packages/@lwc/integration-not-karma/helpers/jasmine.js

@@ -0,0 +1,37 @@
+import { spyOn, fn } from '@vitest/spy';
+
+/**
+ * Adds the jasmine interfaces we use in the Karma tests to a Vitest spy.
+ * Should ultimately be removed and tests updated to use Vitest spies.
+ * @param {import('@vitest/spy').MockInstance}
+ */
+function jasmineSpyAdapter(spy) {
+    Object.defineProperties(spy, {
+        and: { get: () => spy },
+        calls: { get: () => spy.mock.calls },
+        returnValue: { value: () => spy.mockReturnValue() },
+        // calling mockImplementation() with nothing restores the original
+        callThrough: { value: () => spy.mockImplementation() },
+        callFake: { value: (impl) => spy.mockImplementation(impl) },
+    });
+
+    Object.defineProperties(spy.mock.calls, {
+        // Must be non-enumerable for equality checks to work on array literal expected values
+        allArgs: { value: () => spy.mock.calls },
+        count: { value: () => spy.mock.calls.length },
+        reset: { value: () => spy.mockReset() },
+        argsFor: { value: (index) => spy.mock.calls.at(index) },
+    });
+
+    return spy;
+}
+
+export const jasmineSpyOn = (object, prop) => jasmineSpyAdapter(spyOn(object, prop));
+export const jasmine = {
+    any: expect.any,
+    arrayWithExactContents: () => {
+        throw new Error('TODO: jasmine.arrayWithExactContents');
+    },
+    createSpy: (name, impl) => jasmineSpyAdapter(fn(impl)),
+    objectContaining: expect.objectContaining,
+};

packages/@lwc/integration-not-karma/helpers/setup.js

@@ -1,7 +1,6 @@
 // This import ensures that the global `Mocha` object is present for mutation.
 import { JestAsymmetricMatchers, JestChaiExpect, JestExtend } from '@vitest/expect';
 import * as chai from 'chai';
-import { spyOn, fn } from '@vitest/spy';
 import { registerCustomMatchers } from './matchers/index.js';
 import { initSignals } from './signals.js';
 
@@ -15,44 +14,8 @@ chai.use(JestChaiExpect);
 chai.use(JestAsymmetricMatchers);
 // add our custom matchers
 chai.use(registerCustomMatchers);
-
-/**
- * Adds the jasmine interfaces we use in the Karma tests to a Vitest spy.
- * Should ultimately be removed and tests updated to use Vitest spies.
- * @param {import('@vitest/spy').MockInstance}
- */
-function jasmineSpyAdapter(spy) {
-    Object.defineProperties(spy, {
-        and: { get: () => spy },
-        calls: { get: () => spy.mock.calls },
-        returnValue: { value: () => spy.mockReturnValue() },
-        // calling mockImplementation() with nothing restores the original
-        callThrough: { value: () => spy.mockImplementation() },
-        callFake: { value: (impl) => spy.mockImplementation(impl) },
-    });
-
-    Object.defineProperties(spy.mock.calls, {
-        // Must be non-enumerable for equality checks to work on array literal expected values
-        allArgs: { value: () => spy.mock.calls },
-        count: { value: () => spy.mock.calls.length },
-        reset: { value: () => spy.mockReset() },
-        argsFor: { value: (index) => spy.mock.calls.at(index) },
-    });
-
-    return spy;
-}
-
 // expose so we don't need to import `expect` in every test file
 globalThis.expect = chai.expect;
-globalThis.spyOn = (object, prop) => jasmineSpyAdapter(spyOn(object, prop));
-globalThis.jasmine = {
-    any: expect.any,
-    arrayWithExactContents: () => {
-        throw new Error('TODO: jasmine.arrayWithExactContents');
-    },
-    createSpy: (name, impl) => jasmineSpyAdapter(fn(impl)),
-    objectContaining: expect.objectContaining,
-};
 
 /**
  * `@web/test-runner-mocha`'s autorun.js file inlines its own copy of mocha, and there's no direct

packages/@lwc/integration-not-karma/test/accessibility/non-standard-aria-props/index.spec.js

@@ -1,6 +1,7 @@
 import { createElement } from 'lwc';
 import Light from 'x/light';
 import Shadow from 'x/shadow';
+import { jasmine } from '../../../helpers/jasmine.js';
 import { nonStandardAriaProperties } from '../../../helpers/aria.js';
 import {
     attachReportingControlDispatcher,

packages/@lwc/integration-not-karma/test/accessibility/synthetic-cross-root-aria/index.spec.js

@@ -2,6 +2,7 @@ import { createElement } from 'lwc';
 
 import AriaContainer from 'x/ariaContainer';
 import Valid from 'x/valid';
+import { jasmine } from '../../../helpers/jasmine.js';
 import {
     attachReportingControlDispatcher,
     detachReportingControlDispatcher,

packages/@lwc/integration-not-karma/test/api/freezeTemplate/index.spec.js

@@ -1,4 +1,5 @@
 import { registerTemplate, freezeTemplate, setFeatureFlagForTest } from 'lwc';
+import { jasmine } from '../../../helpers/jasmine.js';
 
 import {
     attachReportingControlDispatcher,

packages/@lwc/integration-not-karma/test/api/getComponentDef/index.spec.js

@@ -7,6 +7,7 @@ import PublicPropertiesInheritance from 'x/publicPropertiesInheritance';
 import PublicMethodsInheritance from 'x/publicMethodsInheritance';
 import PrivateAccessors from 'x/privateAccessors';
 import HtmlElementProps from 'x/htmlElementProps';
+import { jasmine } from '../../../helpers/jasmine.js';
 import { ariaProperties } from '../../../helpers/aria.js';
 
 function testInvalidComponentConstructor(name, ctor) {

packages/@lwc/integration-not-karma/test/api/isNodeFromTemplate/index.spec.js

@@ -1,5 +1,6 @@
 import { createElement, isNodeFromTemplate } from 'lwc';
 import Test from 'x/test';
+import { jasmineSpyOn as spyOn } from '../../../helpers/jasmine.js';
 
 function testNonNodes(type, obj) {
     it(`should return false if the passed object if a ${type}`, () => {

packages/@lwc/integration-not-karma/test/api/sanitizeHtmlContent/index.spec.js

@@ -1,5 +1,6 @@
 import { createElement } from 'lwc';
 import XInnerHtml from 'x/innerHtml';
+import { jasmine } from '../../../helpers/jasmine.js';
 import { getHooks, setHooks } from '../../../helpers/hooks.js';
 
 const ACTUAL_CONTENT = 'Hello <b>World</b>';

packages/@lwc/integration-not-karma/test/component/LightningElement.disconnectedCallback/index.spec.js

@@ -5,6 +5,7 @@ import Test from 'x/test';
 import DisconnectedCallbackThrow from 'x/disconnectedCallbackThrow';
 import DualTemplate from 'x/dualTemplate';
 import ExplicitRender from 'x/explicitRender';
+import { jasmine } from '../../../helpers/jasmine.js';
 import { customElementCallbackReactionErrorListener } from '../../../helpers/utils.js';
 
 function testDisconnectSlot(name, fn) {