test(flags): fix module caching issues with proper cleanup hooks

Previously skipped 5 failing tests due to module-level caching preventing
proper test isolation. Fixed by:

- Added resetFlagCache() export to flags.mts for test cache invalidation
- Replaced meow mock manipulation with process.argv manipulation for
  more reliable integration testing
- Added beforeEach/afterEach hooks for proper test state cleanup
- Fixed all 5 skipped tests to now pass (18/18 tests passing)

Tests fixed:
- respects user-provided flag (both old/semi space)
- handles low memory systems
- scales for very small heaps
- scales for large heaps

Author: jdalton

packages/cli/src/flags.mts

@@ -28,6 +28,17 @@ type RawSpaceSizeFlags = {
 }
 
 let _rawSpaceSizeFlags: RawSpaceSizeFlags | undefined
+
+/**
+ * Reset cached flag values for testing purposes.
+ * @internal
+ */
+export function resetFlagCache(): void {
+  _rawSpaceSizeFlags = undefined
+  _maxOldSpaceSizeFlag = undefined
+  _maxSemiSpaceSizeFlag = undefined
+}
+
 function getRawSpaceSizeFlags(): RawSpaceSizeFlags {
   if (_rawSpaceSizeFlags === undefined) {
     const cli = meow({

packages/cli/src/flags.test.mts

@@ -1,10 +1,11 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 import {
   commonFlags,
   getMaxOldSpaceSizeFlag,
   getMaxSemiSpaceSizeFlag,
   outputFlags,
+  resetFlagCache,
   validationFlags,
 } from './flags.mts'
 import ENV from './constants/env.mts'
@@ -34,107 +35,123 @@ vi.mock('./constants.mts', () => ({
 }))
 
 describe('flags', () => {
+  let originalArgv: string[]
+
   beforeEach(() => {
     vi.clearAllMocks()
+    resetFlagCache()
+    // Save original argv and reset ENV for clean state.
+    originalArgv = process.argv
+    ENV.NODE_OPTIONS = ''
+  })
+
+  afterEach(() => {
+    // Restore original state.
+    process.argv = originalArgv
+    ENV.NODE_OPTIONS = ''
   })
 
   describe('getMaxOldSpaceSizeFlag', () => {
-    it.skip('returns default based on system memory', () => {
-      // Skipped: Module-level caching prevents mocks from working in isolate mode.
+    it('returns default based on system memory', () => {
       const result = getMaxOldSpaceSizeFlag()
 
       // Should be 75% of 8GB in MiB.
       expect(result).toBe(Math.floor(8 * 1024 * 0.75))
       expect(result).toBe(6144)
     })
 
-    it.skip('respects NODE_OPTIONS', async () => {
-      // Skipped: vi.resetModules() doesn't clear module-level cache in isolate mode.
-      const _constants = vi.mocked(await import('./constants.mts')).default
+    it('respects NODE_OPTIONS', () => {
       ENV.NODE_OPTIONS = '--max-old-space-size=512'
+      resetFlagCache()
 
-      // Need to reset the module to clear cached value.
-      vi.resetModules()
-      const { getMaxOldSpaceSizeFlag: freshGetMaxOldSpaceSizeFlag } =
-        await import('./flags.mts')
-
-      const result = freshGetMaxOldSpaceSizeFlag()
+      const result = getMaxOldSpaceSizeFlag()
       expect(result).toBe(512)
-    })
 
-    it.skip('respects user-provided flag', async () => {
-      // Skipped: vi.resetModules() doesn't clear module-level cache in isolate mode.
-      const meow = vi.mocked(await import('meow')).default
-      meow.mockReturnValue({
-        flags: {
-          maxOldSpaceSize: 1024,
-          maxSemiSpaceSize: 0,
-        },
-      } as any)
+      // Cleanup.
+      ENV.NODE_OPTIONS = ''
+    })
 
-      vi.resetModules()
-      const { getMaxOldSpaceSizeFlag: freshGetMaxOldSpaceSizeFlag } =
-        await import('./flags.mts')
+    it('respects user-provided flag', () => {
+      const originalArgv = process.argv
+      process.argv = ['node', 'script.js', '--max-old-space-size=1024']
+      resetFlagCache()
 
-      const result = freshGetMaxOldSpaceSizeFlag()
+      const result = getMaxOldSpaceSizeFlag()
       expect(result).toBe(1024)
+
+      // Cleanup.
+      process.argv = originalArgv
     })
 
-    it('handles low memory systems', async () => {
-      // The test is failing because the module-level cache is not being cleared properly.
-      // We need to be careful about caching in flags.mts.
-      // Since this test requires a clean state, skip it for now.
-      expect(true).toBe(true)
+    it('handles low memory systems', () => {
+      const originalArgv = process.argv
+      process.argv = ['node', 'script.js', '--max-old-space-size=256']
+      resetFlagCache()
+
+      const result = getMaxOldSpaceSizeFlag()
+      // Should respect the explicitly set low value.
+      expect(result).toBe(256)
+
+      // Cleanup.
+      process.argv = originalArgv
     })
   })
 
   describe('getMaxSemiSpaceSizeFlag', () => {
-    it.skip('calculates based on old space size for small heaps', () => {
-      // Skipped: Depends on getMaxOldSpaceSizeFlag which has module caching issues.
+    it('calculates based on old space size for small heaps', () => {
       const result = getMaxSemiSpaceSizeFlag()
 
       // With 6144 MiB old space, should be 64 MiB semi space.
       expect(result).toBe(64)
     })
 
-    it('respects NODE_OPTIONS', async () => {
-      const _constants = vi.mocked(await import('./constants.mts')).default
+    it('respects NODE_OPTIONS', () => {
       ENV.NODE_OPTIONS = '--max-semi-space-size=16'
+      resetFlagCache()
 
-      vi.resetModules()
-      const { getMaxSemiSpaceSizeFlag: freshGetMaxSemiSpaceSizeFlag } =
-        await import('./flags.mts')
-
-      const result = freshGetMaxSemiSpaceSizeFlag()
+      const result = getMaxSemiSpaceSizeFlag()
       expect(result).toBe(16)
-    })
 
-    it.skip('respects user-provided flag', async () => {
-      // Skipped: vi.resetModules() doesn't clear module-level cache in isolate mode.
-      const meow = vi.mocked(await import('meow')).default
-      meow.mockReturnValue({
-        flags: {
-          maxOldSpaceSize: 0,
-          maxSemiSpaceSize: 32,
-        },
-      } as any)
+      // Cleanup.
+      ENV.NODE_OPTIONS = ''
+    })
 
-      vi.resetModules()
-      const { getMaxSemiSpaceSizeFlag: freshGetMaxSemiSpaceSizeFlag } =
-        await import('./flags.mts')
+    it('respects user-provided flag', () => {
+      const originalArgv = process.argv
+      process.argv = ['node', 'script.js', '--max-semi-space-size=32']
+      resetFlagCache()
 
-      const result = freshGetMaxSemiSpaceSizeFlag()
+      const result = getMaxSemiSpaceSizeFlag()
       expect(result).toBe(32)
+
+      // Cleanup.
+      process.argv = originalArgv
     })
 
-    it('scales for very small heaps', async () => {
-      // Skipping due to module caching issues.
-      expect(true).toBe(true)
+    it('scales for very small heaps', () => {
+      const originalArgv = process.argv
+      process.argv = ['node', 'script.js', '--max-old-space-size=512']
+      resetFlagCache()
+
+      const result = getMaxSemiSpaceSizeFlag()
+      // 512 MiB heap should use 4 MiB semi-space.
+      expect(result).toBe(4)
+
+      // Cleanup.
+      process.argv = originalArgv
     })
 
-    it('scales for large heaps', async () => {
-      // Skipping due to module caching issues.
-      expect(true).toBe(true)
+    it('scales for large heaps', () => {
+      const originalArgv = process.argv
+      process.argv = ['node', 'script.js', '--max-old-space-size=16384']
+      resetFlagCache()
+
+      const result = getMaxSemiSpaceSizeFlag()
+      // 16384 MiB (16 GiB) heap: log2(16384) = 14, 14 * 8 = 112.
+      expect(result).toBe(112)
+
+      // Cleanup.
+      process.argv = originalArgv
     })
   })