feat: Add per-test configurable TypeScript mocks for flexible offline testing (#12)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: franky47 <1174092+franky47@users.noreply.github.com>

Author: Copilot

packages/mtsv/src/lib/services.test.ts

@@ -1,14 +1,28 @@
 // test/example.test.ts
 // @vitest-environment node
 import { describe } from 'node:test'
-import { expect, it } from 'vitest'
+import { expect, it, beforeEach, afterEach } from 'vitest'
 import { fetchTypeScriptVersions } from './services'
+import { configureTestServer, resetTestServer } from '../mocks/test-setup'
 
 describe('fetchTypeScriptVersions', () => {
+  beforeEach(() => {
+    // Configure a standard set of versions for services testing
+    configureTestServer({
+      '4.0.0': true,
+      '5.0.0': true
+    })
+  })
+
+  afterEach(() => {
+    resetTestServer()
+  })
+
   it('fetches a list of versions for TypeScript', async () => {
     const versionsPromise = fetchTypeScriptVersions()
     await expect(versionsPromise).resolves.toEqual(['4.0.0', '5.0.0'])
   })
+
   it('includes dev versions when asked to', async () => {
     const versionsPromise = fetchTypeScriptVersions({ includeDev: true })
     await expect(versionsPromise).resolves.toEqual([
@@ -17,6 +31,7 @@ describe('fetchTypeScriptVersions', () => {
       '5.1.0-dev.20240101'
     ])
   })
+
   it('includes rc versions when asked to', async () => {
     const versionsPromise = fetchTypeScriptVersions({ includeRc: true })
     await expect(versionsPromise).resolves.toEqual([
@@ -25,6 +40,7 @@ describe('fetchTypeScriptVersions', () => {
       '5.1.0-rc.20240101'
     ])
   })
+
   it('includes insiders versions when asked to', async () => {
     const versionsPromise = fetchTypeScriptVersions({ includeInsiders: true })
     await expect(versionsPromise).resolves.toEqual([
@@ -33,6 +49,7 @@ describe('fetchTypeScriptVersions', () => {
       '5.1.0-insiders.20240101'
     ])
   })
+
   it('includes beta versions when asked to', async () => {
     const versionsPromise = fetchTypeScriptVersions({ includeBeta: true })
     await expect(versionsPromise).resolves.toEqual([

packages/mtsv/src/lib/typescript-cache.test.ts

@@ -0,0 +1,204 @@
+// @vitest-environment node
+import { describe, expect, it, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { resolve } from 'node:path'
+import {
+  TypeScriptCDNCache,
+  TypeScriptMemoryCache,
+  type TypeScriptCacheInterface
+} from './typescript-cache'
+import {
+  configureTestServer,
+  resetTestServer,
+  testConfigs
+} from '../mocks/test-setup'
+
+describe('TypeScript Cache Classes', () => {
+  describe('TypeScriptMemoryCache', () => {
+    let cache: TypeScriptMemoryCache
+
+    beforeEach(() => {
+      cache = new TypeScriptMemoryCache()
+    })
+
+    it('should create an empty cache', () => {
+      expect(cache.memoryCache.size).toBe(0)
+      expect(cache.path).toBe('(in-memory)')
+    })
+
+    it('should throw error for unknown versions', async () => {
+      await expect(cache.load('4.0.0')).rejects.toThrow(
+        'TypeScript version 4.0.0 not in cache'
+      )
+    })
+
+    it('should clear the cache', () => {
+      // Add a mock module to the cache
+      const mockModule = { version: '4.0.0' } as any
+      cache.memoryCache.set('4.0.0', mockModule)
+
+      expect(cache.memoryCache.size).toBe(1)
+      cache.clear()
+      expect(cache.memoryCache.size).toBe(0)
+    })
+
+    it('should free specific versions', () => {
+      const mockModule = { version: '4.0.0' } as any
+      cache.memoryCache.set('4.0.0', mockModule)
+
+      expect(cache.memoryCache.has('4.0.0')).toBe(true)
+      cache.free('4.0.0')
+      expect(cache.memoryCache.has('4.0.0')).toBe(false)
+    })
+
+    it('should purge the cache', async () => {
+      const mockModule = { version: '4.0.0' } as any
+      cache.memoryCache.set('4.0.0', mockModule)
+
+      expect(cache.memoryCache.size).toBe(1)
+      await cache.purge()
+      expect(cache.memoryCache.size).toBe(0)
+    })
+  })
+
+  describe('TypeScriptCDNCache', () => {
+    let cache: TypeScriptCDNCache
+    let tempDir: string
+
+    beforeEach(() => {
+      tempDir = mkdtempSync(resolve(tmpdir(), 'mtsv-test-'))
+      cache = new TypeScriptCDNCache(tempDir)
+    })
+
+    afterEach(() => {
+      // Clean up temp directory
+      rmSync(tempDir, { recursive: true, force: true })
+      resetTestServer() // Reset to default handlers after each test
+    })
+
+    it('should create cache with correct path', () => {
+      expect(cache.path).toBe(resolve(tempDir, 'mtsv-cache'))
+    })
+
+    it('should load TypeScript version from CDN (mocked)', async () => {
+      // Configure test to provide a passing TypeScript 4.0.0 version
+      configureTestServer(testConfigs.singlePass('4.0.0'))
+
+      const tsModule = await cache.load('4.0.0')
+
+      expect(tsModule).toBeDefined()
+      expect(tsModule.version).toBe('4.0.0')
+      expect(tsModule.ScriptTarget).toBeDefined()
+    })
+
+    it('should throw error for non-existent versions', async () => {
+      // Configure test with only 4.0.0 available
+      configureTestServer(testConfigs.singlePass('4.0.0'))
+
+      await expect(cache.load('99.0.0')).rejects.toThrow(
+        'Failed to fetch TypeScript 99.0.0'
+      )
+    })
+
+    it('should cache loaded modules in memory', async () => {
+      // Configure test to provide TypeScript 4.0.0
+      configureTestServer(testConfigs.singlePass('4.0.0'))
+
+      // Load the same version twice
+      const tsModule1 = await cache.load('4.0.0')
+      const tsModule2 = await cache.load('4.0.0')
+
+      // Both should be valid TypeScript modules
+      expect(tsModule1).toBeDefined()
+      expect(tsModule2).toBeDefined()
+      expect(tsModule1.version).toBe('4.0.0')
+      expect(tsModule2.version).toBe('4.0.0')
+      expect(tsModule1.ScriptTarget).toEqual(tsModule2.ScriptTarget)
+    })
+
+    it('should free cached modules', async () => {
+      // Configure test to provide TypeScript 4.0.0
+      configureTestServer(testConfigs.singlePass('4.0.0'))
+
+      const tsModule1 = await cache.load('4.0.0')
+      cache.free('4.0.0')
+
+      // Loading again should still work (from disk cache since mocked)
+      const tsModule2 = await cache.load('4.0.0')
+      expect(tsModule1.version).toBe('4.0.0')
+      expect(tsModule2.version).toBe('4.0.0')
+    })
+
+    it('should clear all cached modules', async () => {
+      // Configure test to provide multiple TypeScript versions
+      configureTestServer({
+        '4.0.0': true,
+        '5.0.0': true
+      })
+
+      await cache.load('4.0.0')
+      await cache.load('5.0.0')
+
+      // Clear should remove from memory but files should still exist
+      cache.clear()
+
+      // Loading again should work (from disk)
+      const tsModule = await cache.load('4.0.0')
+      expect(tsModule).toBeDefined()
+    })
+
+    it('should purge cache directory', async () => {
+      // Configure test to provide TypeScript 4.0.0
+      configureTestServer(testConfigs.singlePass('4.0.0'))
+
+      await cache.load('4.0.0')
+
+      // Purge should remove everything
+      await cache.purge()
+
+      // Loading again should fetch from CDN
+      const tsModule = await cache.load('4.0.0')
+      expect(tsModule).toBeDefined()
+    })
+  })
+
+  describe('Cache Interface Compliance', () => {
+    const testCacheInterface = (
+      createCache: () => TypeScriptCacheInterface
+    ) => {
+      let cache: TypeScriptCacheInterface
+
+      beforeEach(() => {
+        cache = createCache()
+      })
+
+      it('should have all required methods', () => {
+        expect(typeof cache.load).toBe('function')
+        expect(typeof cache.free).toBe('function')
+        expect(typeof cache.clear).toBe('function')
+        expect(typeof cache.purge).toBe('function')
+        expect(typeof cache.path).toBe('string')
+      })
+    }
+
+    describe('TypeScriptMemoryCache interface compliance', () => {
+      testCacheInterface(() => new TypeScriptMemoryCache())
+    })
+
+    describe('TypeScriptCDNCache interface compliance', () => {
+      let tempDir: string
+
+      beforeEach(() => {
+        tempDir = mkdtempSync(resolve(tmpdir(), 'mtsv-test-'))
+      })
+
+      afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true })
+        resetTestServer() // Reset handlers after each test
+      })
+
+      testCacheInterface(() => new TypeScriptCDNCache(tempDir))
+    })
+  })
+})

packages/mtsv/src/lib/typescript-cache.ts

@@ -1,4 +1,4 @@
-import { mkdir, rmdir, stat, writeFile } from 'node:fs/promises'
+import { mkdir, rmdir, stat, writeFile, rm } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import { tmpdir } from 'node:os'
 import { dirname, resolve } from 'node:path'
@@ -91,7 +91,9 @@ export class TypeScriptCDNCache implements TypeScriptCacheInterface {
 
   async load(version: string): Promise<TypeScriptModule> {
     const filePath = this.#resolveVersionFile(version)
-    let tsModule = this.require.cache[filePath] as TypeScriptModule | undefined
+    let tsModule = this.require.cache[filePath]?.exports as
+      | TypeScriptModule
+      | undefined
     if (tsModule) {
       return tsModule
     }
@@ -112,9 +114,8 @@ export class TypeScriptCDNCache implements TypeScriptCacheInterface {
   }
 
   free(version: string): void {
-    delete this.require.cache[
-      this.require.resolve(this.#resolveVersionFile(version))
-    ]
+    const filePath = this.#resolveVersionFile(version)
+    delete this.require.cache[filePath]
   }
 
   clear(): void {
@@ -128,7 +129,7 @@ export class TypeScriptCDNCache implements TypeScriptCacheInterface {
 
   async purge(): Promise<void> {
     // Also remove from disk
-    return rmdir(this.basePath, { recursive: true }).catch(() => {})
+    return rm(this.basePath, { recursive: true }).catch(() => {})
   }
   get path(): string {
     return this.basePath

packages/mtsv/src/mocks/configurable-handlers.test.ts

@@ -0,0 +1,85 @@
+// src/mocks/configurable-handlers.test.ts
+import { describe, expect, it, beforeEach, afterEach } from 'vitest'
+import { configureTestServer, resetTestServer, testConfigs } from './test-setup'
+import { TypeScriptCDNCache } from '../lib/typescript-cache'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { resolve } from 'node:path'
+
+describe('Configurable TypeScript Handlers', () => {
+  let tempDir: string
+  let cache: TypeScriptCDNCache
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(resolve(tmpdir(), 'mtsv-configurable-test-'))
+    cache = new TypeScriptCDNCache(tempDir)
+  })
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true })
+    resetTestServer() // Reset to default handlers after each test
+  })
+
+  describe('single passing version', () => {
+    it('should load a passing TypeScript version successfully', async () => {
+      configureTestServer(testConfigs.singlePass('4.0.0'))
+
+      const tsModule = await cache.load('4.0.0')
+
+      expect(tsModule).toBeDefined()
+      expect(tsModule.version).toBe('4.0.0')
+      expect(tsModule.ScriptTarget).toBeDefined()
+
+      // Verify it's configured to pass (no diagnostics errors)
+      const program = tsModule.createProgram()
+      expect(program.getSyntacticDiagnostics()).toEqual([])
+      expect(program.getSemanticDiagnostics()).toEqual([])
+    })
+
+    it('should return 404 for non-configured versions', async () => {
+      configureTestServer(testConfigs.singlePass('4.0.0'))
+
+      await expect(cache.load('99.0.0')).rejects.toThrow(
+        'Failed to fetch TypeScript 99.0.0'
+      )
+    })
+  })
+
+  describe('single failing version', () => {
+    it('should load a failing TypeScript version with diagnostics', async () => {
+      configureTestServer(testConfigs.singleFail('3.9.0'))
+
+      const tsModule = await cache.load('3.9.0')
+
+      expect(tsModule).toBeDefined()
+      expect(tsModule.version).toBe('3.9.0')
+
+      // Verify it's configured to fail (has diagnostics errors)
+      const program = tsModule.createProgram()
+      const diagnostics = program.getSyntacticDiagnostics()
+      expect(diagnostics).toHaveLength(1)
+      expect(diagnostics[0]).toMatchObject({
+        category: 1, // Error
+        code: 2345
+      })
+    })
+  })
+
+  describe('mixed configuration', () => {
+    it('should handle passing and failing versions correctly', async () => {
+      configureTestServer(testConfigs.mixed())
+
+      // Test a passing version
+      const passingTs = await cache.load('4.0.0')
+      expect(passingTs.version).toBe('4.0.0')
+      expect(passingTs.createProgram().getSyntacticDiagnostics()).toEqual([])
+
+      // Test a failing version
+      const failingTs = await cache.load('3.9.0')
+      expect(failingTs.version).toBe('3.9.0')
+      expect(failingTs.createProgram().getSyntacticDiagnostics()).toHaveLength(
+        1
+      )
+    })
+  })
+})