Open History to see the last commit
1import { spawn } from 'node:child_process'
2import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
3import { createServer } from 'node:net'
4import { resolve } from 'node:path'
5import { expect, test } from '@playwright/test'
6import type { ChildProcess } from 'node:child_process'
7import type { Page, Request } from '@playwright/test'
8β
9const appDir = resolve(import.meta.dirname, '..')
10const cacheDir = resolve(appDir, 'node_modules/.cache/rspack')
11const consistentRoutePath = resolve(appDir, 'src/routes/consistent.tsx')
12const noServerFunctionsConsistentRouteSource = `import { createFileRoute } from '@tanstack/react-router'
13β
14export const Route = createFileRoute('/consistent')({
15 component: ConsistentServerFnCalls,
16})
17β
18function ConsistentServerFnCalls() {
19 return (
20 <div data-testid="watch-no-server-functions">
21 Server functions removed by watch test
22 </div>
23 )
24}
25`
26β
27interface ServerFnRequest {
28 method: string
29 url: string
30}
31β
32interface DevServer {
33 child: ChildProcess
34 logs: Array<string>
35 port: number
36}
37β
38let navigationId = 0
39β
40async function delay(ms: number): Promise<void> {
41 await new Promise((resolve) => setTimeout(resolve, ms))
42}
43β
44async function getAvailablePort(): Promise<number> {
45 return await new Promise((resolvePromise, reject) => {
46 const server = createServer()
47β
48 server.unref()
49 server.once('error', reject)
50 server.listen(0, '127.0.0.1', () => {
51 const address = server.address()
52β
53 if (!address || typeof address === 'string') {
54 server.close(() => reject(new Error('Could not allocate a port')))
55 return
56 }
57β
58 const { port } = address
59 server.close((error) => {
60 if (error) {
61 reject(error)
62 return
63 }
64β
65 resolvePromise(port)
66 })
67 })
68 })
69}
70β
71async function canListen(port: number): Promise<boolean> {
72 return await new Promise((resolvePromise) => {
73 const server = createServer()
74β
75 const finish = (value: boolean) => {
76 server.removeAllListeners()
77 resolvePromise(value)
78 }
79β
80 server.unref()
81 server.once('error', () => finish(false))
82 server.listen(port, '127.0.0.1', () => {
83 server.close((error) => finish(!error))
84 })
85 })
86}
87β
88async function waitForPortAvailable(port: number): Promise<void> {
89 const start = Date.now()
90β
91 while (Date.now() - start < 10_000) {
92 if (await canListen(port)) {
93 return
94 }
95β
96 await delay(100)
97 }
98β
99 throw new Error(`Timed out waiting for port ${port} to be released`)
100}
101β
102function startRsbuildDevServer(
103 port: number,
104 buildCacheEnabled = true,
105): DevServer {
106 const logs: Array<string> = []
107 const child = spawn(
108 'pnpm',
109 ['exec', 'rsbuild', 'dev', '--host', '127.0.0.1', '--port', String(port)],
110 {
111 cwd: appDir,
112 detached: true,
113 env: {
114 ...process.env,
115 PORT: String(port),
116 VITE_SERVER_PORT: String(port),
117 VITE_NODE_ENV: 'test',
118 E2E_RSBUILD_BUILD_CACHE: buildCacheEnabled ? 'true' : 'false',
119 },
120 stdio: ['ignore', 'pipe', 'pipe'],
121 },
122 )
123β
124 child.stdout?.on('data', (chunk: Buffer) => logs.push(chunk.toString()))
125 child.stderr?.on('data', (chunk: Buffer) => logs.push(chunk.toString()))
126β
127 return { child, logs, port }
128}
129β
130function killDevServer(devServer: DevServer, signal: NodeJS.Signals) {
131 const pid = devServer.child.pid
132β
133 try {
134 if (pid) {
135 process.kill(-pid, signal)
136 return
137 }
138 } catch {
139 // Fall back to killing the direct child below.
140 }
141β
142 devServer.child.kill(signal)
143}
144β
145async function waitForHttpOk(devServer: DevServer, url: string): Promise<void> {
146 const start = Date.now()
147β
148 while (Date.now() - start < 60_000) {
149 if (devServer.child.exitCode !== null) {
150 throw new Error(
151 `Rsbuild dev server exited before ${url} was ready.\n${devServer.logs.join('')}`,
152 )
153 }
154β
155 try {
156 const response = await fetch(url, {
157 signal: AbortSignal.timeout(1000),
158 })
159β
160 if (response.status >= 200 && response.status < 400) {
161 return
162 }
163 } catch {
164 // Wait until the dev server starts accepting requests.
165 }
166β
167 await delay(250)
168 }
169β
170 throw new Error(
171 `Timed out waiting for Rsbuild dev server at ${url}.\n${devServer.logs.join('')}`,
172 )
173}
174β
175async function stopDevServer(devServer: DevServer): Promise<void> {
176 if (devServer.child.exitCode !== null || devServer.child.killed) {
177 return
178 }
179β
180 await new Promise<void>((resolve) => {
181 let settled = false
182 let killTimer: ReturnType<typeof setTimeout> | undefined
183 let doneTimer: ReturnType<typeof setTimeout> | undefined
184β
185 const done = () => {
186 if (settled) {
187 return
188 }
189 settled = true
190 if (killTimer) {
191 clearTimeout(killTimer)
192 }
193 if (doneTimer) {
194 clearTimeout(doneTimer)
195 }
196 resolve()
197 }
198β
199 devServer.child.once('exit', done)
200 devServer.child.once('error', done)
201β
202 try {
203 killDevServer(devServer, 'SIGTERM')
204 } catch {
205 done()
206 return
207 }
208β
209 killTimer = setTimeout(() => {
210 try {
211 killDevServer(devServer, 'SIGKILL')
212 } catch {
213 // The process may have already exited.
214 }
215β
216 doneTimer = setTimeout(done, 500)
217 }, 3000)
218 })
219β
220 await waitForPortAvailable(devServer.port)
221}
222β
223async function waitForRetry<T>(
224 devServer: DevServer,
225 description: string,
226 action: () => Promise<T>,
227): Promise<T> {
228 const start = Date.now()
229 let lastError: unknown
230β
231 while (Date.now() - start < 30_000) {
232 if (devServer.child.exitCode !== null) {
233 throw new Error(
234 `Rsbuild dev server exited while waiting for ${description}.\n${devServer.logs.join('')}`,
235 )
236 }
237β
238 try {
239 return await action()
240 } catch (error) {
241 lastError = error
242 await delay(500)
243 }
244 }
245β
246 throw new Error(
247 `Timed out waiting for ${description}.\n${lastError instanceof Error ? lastError.stack || lastError.message : String(lastError)}\n\nRsbuild logs:\n${devServer.logs.join('')}`,
248 )
249}
250β
251async function captureServerFnRequests(
252 page: Page,
253 action: () => Promise<void>,
254): Promise<Array<ServerFnRequest>> {
255 const requests: Array<ServerFnRequest> = []
256 const listener = (request: Request) => {
257 if (request.url().includes('/_serverFn/')) {
258 requests.push({
259 method: request.method(),
260 url: request.url(),
261 })
262 }
263 }
264β
265 page.on('request', listener)
266 try {
267 await action()
268 } finally {
269 page.off('request', listener)
270 }
271β
272 return requests
273}
274β
275async function exerciseServerFunctions(
276 page: Page,
277 baseURL: string,
278 expectedUsername = 'TEST',
279) {
280 const response = await page.goto(
281 `${baseURL}/consistent?testRun=${navigationId++}`,
282 {
283 waitUntil: 'networkidle',
284 },
285 )
286 expect(response?.ok()).toBe(true)
287β
288 const expectedLocator = page.getByTestId(
289 'expected-consistent-server-fns-result',
290 )
291 await expect(expectedLocator).toContainText(
292 JSON.stringify({ payload: { username: expectedUsername } }),
293 )
294 const expected = (await expectedLocator.textContent()) || ''
295β
296 await expect(page.getByTestId('consistent-client-hydrated')).toBeAttached()
297β
298 await page.getByTestId('test-consistent-server-fn-calls-btn').click()
299 await page.waitForLoadState('networkidle')
300β
301 await expect(page.getByTestId('cons_serverGetFn1-response')).toContainText(
302 expected,
303 )
304 await expect(page.getByTestId('cons_getFn1-response')).toContainText(expected)
305 await expect(page.getByTestId('cons_serverPostFn1-response')).toContainText(
306 expected,
307 )
308 await expect(page.getByTestId('cons_postFn1-response')).toContainText(
309 expected,
310 )
311}
312β
313async function exerciseServerFunctionsWithLogs(
314 page: Page,
315 baseURL: string,
316 devServer: DevServer,
317 expectedUsername = 'TEST',
318) {
319 try {
320 await exerciseServerFunctions(page, baseURL, expectedUsername)
321 } catch (error) {
322 throw new Error(
323 `${error instanceof Error ? error.stack || error.message : String(error)}\n\nRsbuild logs:\n${devServer.logs.join('')}`,
324 )
325 }
326}
327β
328async function waitForStaticConsistentRoute(
329 page: Page,
330 baseURL: string,
331 devServer: DevServer,
332) {
333 await waitForRetry(devServer, 'static consistent route update', async () => {
334 const response = await page.goto(
335 `${baseURL}/consistent?watch=${Date.now()}`,
336 {
337 waitUntil: 'networkidle',
338 },
339 )
340 expect(response?.ok()).toBe(true)
341 await expect(page.getByTestId('watch-no-server-functions')).toContainText(
342 'Server functions removed by watch test',
343 { timeout: 1000 },
344 )
345 })
346}
347β
348test('rsbuild build cache warm restart keeps server function registry', async ({
349 page,
350}) => {
351 test.setTimeout(120_000)
352β
353 rmSync(cacheDir, { recursive: true, force: true })
354β
355 const port = await getAvailablePort()
356 const baseURL = `http://127.0.0.1:${port}`
357 let devServer = startRsbuildDevServer(port)
358β
359 try {
360 await waitForHttpOk(devServer, baseURL)
361 await exerciseServerFunctionsWithLogs(page, baseURL, devServer)
362 } finally {
363 await stopDevServer(devServer)
364 }
365β
366 expect(existsSync(cacheDir)).toBe(true)
367β
368 devServer = startRsbuildDevServer(port)
369β
370 try {
371 await waitForHttpOk(devServer, baseURL)
372 await exerciseServerFunctionsWithLogs(page, baseURL, devServer)
373β
374 expect(devServer.logs.join('')).not.toContain(
375 'Server function info not found',
376 )
377 } finally {
378 await stopDevServer(devServer)
379 }
380})
381β
382test('rsbuild without build cache keeps server function registry', async ({
383 page,
384}) => {
385 test.setTimeout(120_000)
386β
387 rmSync(cacheDir, { recursive: true, force: true })
388β
389 const port = await getAvailablePort()
390 const baseURL = `http://127.0.0.1:${port}`
391 const devServer = startRsbuildDevServer(port, false)
392β
393 try {
394 await waitForHttpOk(devServer, baseURL)
395 await exerciseServerFunctionsWithLogs(page, baseURL, devServer)
396β
397 expect(devServer.logs.join('')).not.toContain(
398 'Server function info not found',
399 )
400 } finally {
401 await stopDevServer(devServer)
402 }
403})
404β
405test('rsbuild watch updates and removes server function metadata', async ({
406 page,
407}) => {
408 test.setTimeout(120_000)
409β
410 const originalSource = readFileSync(consistentRoutePath, 'utf8')
411 const updatedSource = originalSource.replaceAll("'TEST'", "'WATCH'")
412 rmSync(cacheDir, { recursive: true, force: true })
413β
414 const port = await getAvailablePort()
415 const baseURL = `http://127.0.0.1:${port}`
416 const devServer = startRsbuildDevServer(port)
417β
418 try {
419 await waitForHttpOk(devServer, baseURL)
420 await exerciseServerFunctionsWithLogs(page, baseURL, devServer)
421β
422 writeFileSync(consistentRoutePath, updatedSource)
423 const serverFnRequests = await waitForRetry(
424 devServer,
425 'updated server function metadata',
426 async () => {
427 return await captureServerFnRequests(page, async () => {
428 await exerciseServerFunctionsWithLogs(
429 page,
430 baseURL,
431 devServer,
432 'WATCH',
433 )
434 })
435 },
436 )
437 const staleGetRequest = serverFnRequests.find(
438 (request) => request.method === 'GET',
439 )
440 expect(staleGetRequest).toBeDefined()
441β
442 writeFileSync(consistentRoutePath, noServerFunctionsConsistentRouteSource)
443 await waitForStaticConsistentRoute(page, baseURL, devServer)
444β
445 const staleResult = await page.evaluate(async (url) => {
446 const response = await fetch(url)
447 return {
448 ok: response.ok,
449 status: response.status,
450 text: await response.text(),
451 }
452 }, staleGetRequest!.url)
453β
454 expect(staleResult.ok).toBe(false)
455 expect(staleResult.status).toBeGreaterThanOrEqual(400)
456 expect(staleResult.text).not.toContain('WATCH')
457 } finally {
458 writeFileSync(consistentRoutePath, originalSource)
459 await stopDevServer(devServer)
460 }
461})