Open History to see the last commit
1import { describe, expect, test } from 'vitest'
2import {
3 MOCK_EDGE_PREFIX,
4 MOCK_MODULE_ID,
5 MOCK_RUNTIME_PREFIX,
6 generateDevSelfDenialModule,
7 generateSelfContainedMockModule,
8 loadMarkerModule,
9 loadMockEdgeModule,
10 loadMockRuntimeModule,
11 loadSilentMockModule,
12 makeMockEdgeModuleId,
13 mockRuntimeModuleIdFromViolation,
14} from '../../src/vite/import-protection-plugin/virtualModules'
15import type { ViolationInfo } from '../../src/import-protection/trace'
16β
17type MockValue = {
18 toString: () => string
19 valueOf: () => string
20 toJSON: () => string
21}
22β
23type MockFunction = {
24 (): MockValue
25}
26β
27function evaluateGeneratedModule<T>(code: string): T {
28 const exports: Record<string, unknown> = {}
29 const runnableCode = code
30 .replace(/export default mock;?/g, 'exports.default = mock;')
31 .replace(/export const ([A-Za-z_$][\w$]*) = ([^;]+);/g, 'exports.$1 = $2;')
32β
33 new Function('exports', runnableCode)(exports)
34 return exports as T
35}
36β
37describe('loadSilentMockModule', () => {
38 test('returns mock code', () => {
39 const result = loadSilentMockModule()
40 expect(result.code).toContain('export default mock')
41 expect(result.code).toContain('createMock')
42 expect(result.code).toContain('Proxy')
43 expect(result.code).toContain('@__NO_SIDE_EFFECTS__')
44 expect(result.code).toContain('@__PURE__')
45 })
46β
47 test('supports primitive conversion for called mocks', () => {
48 const result = loadSilentMockModule()
49 const mod = evaluateGeneratedModule<{ default: MockFunction }>(result.code)
50 const value = mod.default()
51β
52 expect(String(value)).toBe('[import-protection mock]')
53 expect(value.toString()).toBe('[import-protection mock]')
54 expect(value.valueOf()).toBe('[import-protection mock]')
55 expect(JSON.stringify(value)).toBe('"[import-protection mock]"')
56 })
57})
58β
59describe('loadMarkerModule', () => {
60 test('returns empty module', () => {
61 const result = loadMarkerModule()
62 expect(result.code).toBe('export {}')
63 })
64})
65β
66describe('loadMockEdgeModule', () => {
67 test('generates named exports from payload', () => {
68 const payload = JSON.stringify({
69 exports: ['getSecret', 'initDb'],
70 runtimeId: MOCK_MODULE_ID,
71 })
72 const encoded = Buffer.from(payload, 'utf8').toString('base64url')
73 const result = loadMockEdgeModule(encoded)
74β
75 expect(result.code).toContain('export const getSecret')
76 expect(result.code).toContain('export const initDb')
77 expect(result.code).toContain('export default mock')
78 })
79β
80 test('handles empty exports array', () => {
81 const payload = JSON.stringify({
82 exports: [],
83 runtimeId: MOCK_MODULE_ID,
84 })
85 const encoded = Buffer.from(payload, 'utf8').toString('base64url')
86 const result = loadMockEdgeModule(encoded)
87β
88 expect(result.code).toContain('export default mock')
89 expect(result.code).not.toContain('export const')
90 })
91β
92 test('handles string-keyed (non-identifier) export names via re-export', () => {
93 const payload = JSON.stringify({
94 exports: ['valid', 'default', '123invalid', 'also-invalid'],
95 runtimeId: MOCK_MODULE_ID,
96 })
97 const encoded = Buffer.from(payload, 'utf8').toString('base64url')
98 const result = loadMockEdgeModule(encoded)
99β
100 // Valid identifier: direct const export
101 expect(result.code).toContain('export const valid')
102 // 'default' is filtered out
103 expect(result.code).not.toContain('export const default')
104 // Non-identifiers get string-keyed re-exports
105 expect(result.code).toContain('__tss_str_')
106 expect(result.code).toContain('"123invalid"')
107 expect(result.code).toContain('"also-invalid"')
108 })
109β
110 test('handles malformed base64', () => {
111 const result = loadMockEdgeModule('not-valid-base64!!!')
112 expect(result.code).toContain('export default mock')
113 })
114β
115 test('falls back to MOCK_MODULE_ID when runtimeId missing', () => {
116 const payload = JSON.stringify({
117 exports: ['a'],
118 })
119 const encoded = Buffer.from(payload, 'utf8').toString('base64url')
120 const result = loadMockEdgeModule(encoded)
121β
122 expect(result.code).toContain(MOCK_MODULE_ID)
123 })
124})
125β
126describe('loadMockRuntimeModule', () => {
127 test('generates runtime diagnostic module with error mode', () => {
128 const payload = JSON.stringify({
129 mode: 'error',
130 env: 'client',
131 importer: '/src/routes/index.tsx',
132 specifier: './secret.server',
133 trace: ['src/main.tsx', 'src/routes/index.tsx'],
134 })
135 const encoded = Buffer.from(payload, 'utf8').toString('base64url')
136 const result = loadMockRuntimeModule(encoded)
137β
138 expect(result.code).toContain('__report')
139 expect(result.code).toContain('console.error')
140 expect(result.code).toContain('"error"')
141 expect(result.code).toContain('export default mock')
142 })
143β
144 test('generates warn mode module', () => {
145 const payload = JSON.stringify({ mode: 'warn' })
146 const encoded = Buffer.from(payload, 'utf8').toString('base64url')
147 const result = loadMockRuntimeModule(encoded)
148β
149 expect(result.code).toContain('"warn"')
150 expect(result.code).toContain('console.warn')
151 })
152β
153 test('handles malformed payload gracefully', () => {
154 const result = loadMockRuntimeModule('bad-data')
155 expect(result.code).toContain('export default mock')
156 })
157})
158β
159describe('mockRuntimeModuleIdFromViolation', () => {
160 const baseViolation: ViolationInfo = {
161 env: 'client',
162 envType: 'client',
163 type: 'file',
164 behavior: 'mock',
165 specifier: './secret.server',
166 importer: '/project/src/routes/index.tsx',
167 trace: [
168 { file: '/project/src/main.tsx' },
169 { file: '/project/src/routes/index.tsx', specifier: './secret.server' },
170 ],
171 }
172β
173 test('returns MOCK_MODULE_ID when mode is off', () => {
174 const id = mockRuntimeModuleIdFromViolation(
175 baseViolation,
176 'off',
177 '/project',
178 )
179 expect(id).toBe(MOCK_MODULE_ID)
180 })
181β
182 test('returns MOCK_MODULE_ID for non-client env', () => {
183 const ssrViolation = { ...baseViolation, env: 'ssr' }
184 const id = mockRuntimeModuleIdFromViolation(
185 ssrViolation,
186 'error',
187 '/project',
188 )
189 expect(id).toBe(MOCK_MODULE_ID)
190 })
191β
192 test('returns runtime module ID for client env with error mode', () => {
193 const id = mockRuntimeModuleIdFromViolation(
194 baseViolation,
195 'error',
196 '/project',
197 )
198 expect(id.startsWith(MOCK_RUNTIME_PREFIX)).toBe(true)
199 const encoded = id.slice(MOCK_RUNTIME_PREFIX.length)
200 const payload = JSON.parse(
201 Buffer.from(encoded, 'base64url').toString('utf8'),
202 )
203 expect(payload.env).toBe('client')
204 expect(payload.mode).toBe('error')
205 expect(payload.specifier).toBe('./secret.server')
206 })
207β
208 test('includes relative trace paths', () => {
209 const id = mockRuntimeModuleIdFromViolation(
210 baseViolation,
211 'warn',
212 '/project',
213 )
214 const encoded = id.slice(MOCK_RUNTIME_PREFIX.length)
215 const payload = JSON.parse(
216 Buffer.from(encoded, 'base64url').toString('utf8'),
217 )
218 expect(payload.trace[0]).toBe('src/main.tsx')
219 })
220β
221 test('includes line numbers in trace when present', () => {
222 const violation: ViolationInfo = {
223 ...baseViolation,
224 trace: [
225 { file: '/project/src/main.tsx' },
226 {
227 file: '/project/src/routes/index.tsx',
228 specifier: './secret.server',
229 line: 5,
230 column: 10,
231 },
232 ],
233 }
234 const id = mockRuntimeModuleIdFromViolation(violation, 'error', '/project')
235 const encoded = id.slice(MOCK_RUNTIME_PREFIX.length)
236 const payload = JSON.parse(
237 Buffer.from(encoded, 'base64url').toString('utf8'),
238 )
239 expect(payload.trace[1]).toBe('src/routes/index.tsx:5:10')
240 })
241})
242β
243describe('makeMockEdgeModuleId', () => {
244 test('encodes exports into module ID payload', () => {
245 const id = makeMockEdgeModuleId(['foo', 'bar'], MOCK_MODULE_ID)
246 expect(id.startsWith(MOCK_EDGE_PREFIX)).toBe(true)
247 const encoded = id.slice(MOCK_EDGE_PREFIX.length)
248 const payload = JSON.parse(
249 Buffer.from(encoded, 'base64url').toString('utf8'),
250 )
251 expect(payload.exports).toEqual(['foo', 'bar'])
252 expect(payload.runtimeId).toBe(MOCK_MODULE_ID)
253 })
254β
255 test('handles empty exports', () => {
256 const id = makeMockEdgeModuleId([], MOCK_MODULE_ID)
257 const encoded = id.slice(MOCK_EDGE_PREFIX.length)
258 const payload = JSON.parse(
259 Buffer.from(encoded, 'base64url').toString('utf8'),
260 )
261 expect(payload.exports).toEqual([])
262 })
263})
264β
265describe('generateSelfContainedMockModule', () => {
266 test('generates module with named exports', () => {
267 const result = generateSelfContainedMockModule(['getSecret', 'initDb'])
268 expect(result.code).toContain('export const getSecret = mock.getSecret;')
269 expect(result.code).toContain('export const initDb = mock.initDb;')
270 expect(result.code).toContain('export default mock')
271 expect(result.code).toContain('createMock')
272 expect(result.code).toContain('Proxy')
273 })
274β
275 test('handles empty exports', () => {
276 const result = generateSelfContainedMockModule([])
277 expect(result.code).toContain('export default mock')
278 expect(result.code).not.toContain('export const')
279 })
280β
281 test('filters out default export', () => {
282 const result = generateSelfContainedMockModule(['default', 'foo'])
283 expect(result.code).toContain('export const foo = mock.foo;')
284 expect(result.code).not.toContain('export const default')
285 })
286β
287 test('handles string-keyed (non-identifier) export names via re-export', () => {
288 const result = generateSelfContainedMockModule([
289 'valid',
290 '123invalid',
291 'also-invalid',
292 ])
293 expect(result.code).toContain('export const valid = mock.valid;')
294 expect(result.code).toContain('__tss_str_')
295 expect(result.code).toContain('"123invalid"')
296 expect(result.code).toContain('"also-invalid"')
297 })
298β
299 test('is self-contained (no imports)', () => {
300 const result = generateSelfContainedMockModule(['foo'])
301 // Should not import from any other module
302 expect(result.code).not.toMatch(/^\s*import\s/m)
303 })
304β
305 test('supports primitive conversion for named export calls', () => {
306 const result = generateSelfContainedMockModule(['getSecret'])
307 const mod = evaluateGeneratedModule<{ getSecret: MockFunction }>(
308 result.code,
309 )
310β
311 expect(String(mod.getSecret())).toBe('[import-protection mock]')
312 })
313})
314β
315describe('generateDevSelfDenialModule', () => {
316 test('generates module with named exports and mock-runtime import', () => {
317 const runtimeId = 'tanstack-start-import-protection:mock-runtime:abc'
318 const result = generateDevSelfDenialModule(
319 ['getSecret', 'initDb'],
320 runtimeId,
321 )
322 expect(result.code).toContain(`import mock from "${runtimeId}"`)
323 expect(result.code).toContain('export const getSecret = mock.getSecret;')
324 expect(result.code).toContain('export const initDb = mock.initDb;')
325 expect(result.code).toContain('export default mock;')
326 })
327β
328 test('handles empty exports', () => {
329 const runtimeId = MOCK_MODULE_ID
330 const result = generateDevSelfDenialModule([], runtimeId)
331 expect(result.code).toContain(`import mock from "${runtimeId}"`)
332 expect(result.code).toContain('export default mock;')
333 expect(result.code).not.toContain('export const')
334 })
335β
336 test('filters out default export', () => {
337 const result = generateDevSelfDenialModule(['default', 'foo'], 'mock-rt:x')
338 expect(result.code).toContain('export const foo = mock.foo;')
339 expect(result.code).not.toContain('export const default')
340 expect(result.code).toContain('export default mock;')
341 })
342β
343 test('imports mock-runtime (not self-contained)', () => {
344 const result = generateDevSelfDenialModule(['foo'], 'mock-rt:xyz')
345 expect(result.code).toMatch(/\bimport\b/)
346 // Should NOT contain inline createMock/Proxy (that's the build-mode mock)
347 expect(result.code).not.toContain('createMock')
348 expect(result.code).not.toContain('Proxy')
349 })
350})