packages/vue-query/src/__tests__/queryClient.test.ts (1)

23-23: This change appears unrelated to the environmentManager feature.

The type improvement for the filter predicate is a good change, but it doesn't seem related to the environmentManager feature being introduced in this PR. Consider whether this should be in a separate PR for cleaner history, or note in the PR description that this is an incidental type improvement.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/vue-query/src/__tests__/queryClient.test.ts` at line 23, The change
to the filter predicate type guard in queryClient.test.ts (the line casting to
QueryClientPrototypeMethod) is unrelated to the environmentManager feature;
either revert that type-only change from this branch and leave the
environmentManager PR focused, or extract the type improvement into its own
commit/branch and open a separate PR; update the current PR description to
mention the incidental type tweak if you intend to keep it here. Ensure you
reference the test file's filter predicate that narrows to
QueryClientPrototypeMethod when making the change.

packages/query-core/src/__tests__/environmentManager.test.tsx (1)

21-24: Consider consolidating or differentiating this test.

This test ("should allow overriding isServer with a function") is essentially identical to the first part of the test on lines 13-15. Both tests call setIsServer(() => true) and assert the result. The test name suggests testing "with a function" but that's already what the API requires—setIsServer only accepts a function per the type IsServerValue = () => boolean.

Consider either removing this test as it's redundant, or differentiating it by testing a more dynamic function (e.g., one that returns different values based on some condition).

Example of a more meaningful test

  test('should allow overriding isServer with a function', () => {
-   environmentManager.setIsServer(() => true)
-   expect(environmentManager.isServer()).toBe(true)
+   let value = true
+   environmentManager.setIsServer(() => value)
+   expect(environmentManager.isServer()).toBe(true)
+   
+   value = false
+   expect(environmentManager.isServer()).toBe(false)
  })

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/query-core/src/__tests__/environmentManager.test.tsx` around lines
21 - 24, The test is redundant because environmentManager.setIsServer(() =>
true) is already asserted earlier; either remove this duplicate test or change
it to exercise a dynamic function: replace the static () => true with a function
that flips or returns different values based on external state, then assert
environmentManager.isServer() reflects that changing state (use
environmentManager.setIsServer and environmentManager.isServer to locate code to
modify). Ensure the new test verifies the dynamic behavior across state changes
rather than repeating the same static assertion.

packages/query-core/src/onlineManager.ts (1)

17-17: Inconsistent with environmentManager pattern used elsewhere.

This change uses typeof window !== 'undefined' directly instead of environmentManager.isServer(). While this works for detecting the browser environment, it creates an inconsistency with the rest of the codebase migration:

• If a user calls environmentManager.setIsServer(() => true) to simulate server-side behavior (e.g., for testing), the OnlineManager will still register window event listeners because window exists.
• Other files (retryer.ts, queryObserver.ts, removable.ts) use environmentManager.isServer() consistently.

If the intent is to check specifically for window.addEventListener availability (as the comment suggests for React Native compatibility), the current approach is fine. However, if the goal is to respect the environmentManager override, consider:

Option: Use environmentManager for consistency

-      if (typeof window !== 'undefined' && window.addEventListener) {
+      if (!environmentManager.isServer() && typeof window !== 'undefined' && window.addEventListener) {

This would require adding the import:

+import { environmentManager } from './environmentManager'

Please clarify the intended behavior: should OnlineManager respect environmentManager.setIsServer() overrides, or is checking for window existence the correct approach here?

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/query-core/src/onlineManager.ts` at line 17, Replace the direct
"typeof window !== 'undefined' && window.addEventListener" check in
OnlineManager with the environmentManager-based guard so the module respects
environmentManager.setIsServer() overrides; import environmentManager and change
the condition to "!environmentManager.isServer() && typeof window !==
'undefined' && window.addEventListener" (so you still guard for environments
like React Native while honoring test/server overrides) and update any
surrounding comment to reflect the combined intent.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

packages/query-core/src/__tests__/focusManager.test.tsx (1)

57-60: Use try/finally for spy restoration to prevent cross-test leakage.

If an assertion fails before Line 76, the mocked globalThis.window getter remains active and can pollute following tests.

Suggested hardening

   test('cleanup (removeEventListener) should not be called if window is not defined', () => {
     const windowSpy = vi.spyOn(globalThis, 'window', 'get')
     windowSpy.mockImplementation(
       () => undefined as unknown as Window & typeof globalThis,
     )
     const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')

-    const subscribe = () => focusManager.subscribe(() => undefined)
-    let firstUnsubscribe: (() => void) | undefined
-
-    expect(() => {
-      firstUnsubscribe = subscribe()
-    }).not.toThrow()
-    const secondUnsubscribe = subscribe()
-
-    firstUnsubscribe?.()
-    secondUnsubscribe()
-
-    expect(removeEventListenerSpy).not.toHaveBeenCalled()
-
-    windowSpy.mockRestore()
+    try {
+      const subscribe = () => focusManager.subscribe(() => undefined)
+      let firstUnsubscribe: (() => void) | undefined
+
+      expect(() => {
+        firstUnsubscribe = subscribe()
+      }).not.toThrow()
+      const secondUnsubscribe = subscribe()
+
+      firstUnsubscribe?.()
+      secondUnsubscribe()
+
+      expect(removeEventListenerSpy).not.toHaveBeenCalled()
+    } finally {
+      removeEventListenerSpy.mockRestore()
+      windowSpy.mockRestore()
+    }
   })

Also applies to: 76-76

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/query-core/src/__tests__/focusManager.test.tsx` around lines 57 -
60, Wrap the test code that mocks globalThis.window (the windowSpy created via
vi.spyOn(globalThis, 'window', 'get')) in a try/finally block so you always
restore the spy; move windowSpy.mockImplementation(...) into the try and call
windowSpy.mockRestore() in the finally to ensure the mocked getter is removed
even if assertions fail (apply the same pattern for the other instance around
line 76).

packages/query-core/src/__tests__/onlineManager.test.tsx (1)

66-69: Guard spy restoration with finally for deterministic test cleanup.

If anything fails before Line 79, the mocked window getter may leak into later tests.

Suggested hardening

   test('cleanup (removeEventListener) should not be called if window is not defined', () => {
     const windowSpy = vi.spyOn(globalThis, 'window', 'get')
     windowSpy.mockImplementation(
       () => undefined as unknown as Window & typeof globalThis,
     )
     const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')

-    const unsubscribe = onlineManager.subscribe(() => undefined)
-    expect(unsubscribe).toBeInstanceOf(Function)
-
-    unsubscribe()
-
-    expect(removeEventListenerSpy).not.toHaveBeenCalled()
-
-    windowSpy.mockRestore()
+    try {
+      const unsubscribe = onlineManager.subscribe(() => undefined)
+      expect(unsubscribe).toBeInstanceOf(Function)
+      unsubscribe()
+      expect(removeEventListenerSpy).not.toHaveBeenCalled()
+    } finally {
+      removeEventListenerSpy.mockRestore()
+      windowSpy.mockRestore()
+    }
   })

Also applies to: 79-79

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/query-core/src/__tests__/onlineManager.test.tsx` around lines 66 -
69, The test creates a spy via vi.spyOn(globalThis, 'window', 'get') assigned to
windowSpy and mocks it with windowSpy.mockImplementation(...); ensure the spy is
always restored to avoid leaking into other tests by wrapping the test body so
that windowSpy.mockRestore() is called in a finally block (or register
windowSpy.mockRestore() in an afterEach/teardown hook) — update the test that
uses windowSpy, mockImplementation, and windowSpy.mockRestore() to guarantee
restoration even if assertions throw.

Configuration used: defaults

Review profile: CHILL

Plan: Pro