prool 0.0.3 → 0.0.5

package/processes/execa.test.ts

@@ -0,0 +1,143 @@
+import { EventEmitter } from 'eventemitter3'
+import { afterEach, expect, test } from 'vitest'
+import { type ExecaProcess, execa } from './execa.js'
+
+const processes: ExecaProcess[] = []
+function createProcess() {
+  const process = execa({ name: 'foo' })
+  processes.push(process)
+  return process
+}
+
+afterEach(async () => {
+  for (const process of processes) await process.stop().catch(() => {})
+})
+
+test('default', async () => {
+  const process = createProcess()
+  expect(process).toMatchInlineSnapshot(`
+    {
+      "_internal": {
+        "process": undefined,
+      },
+      "name": "foo",
+      "start": [Function],
+      "stop": [Function],
+    }
+  `)
+})
+
+test('start', async () => {
+  const emitter = new EventEmitter<any>()
+  const process = createProcess()
+
+  const resolvers = {
+    listening: Promise.withResolvers<void>(),
+    message: Promise.withResolvers<void>(),
+    stdout: Promise.withResolvers<void>(),
+  }
+  emitter.on('listening', resolvers.listening.resolve)
+  emitter.on('message', resolvers.message.resolve)
+  emitter.on('stdout', resolvers.stdout.resolve)
+
+  await process.start(($) => $`anvil --port 1337`, {
+    emitter,
+    status: 'idle',
+    resolver({ process, resolve }) {
+      process.stdout.on('data', (data) => {
+        const message = data.toString()
+        if (message.includes('Listening on')) resolve()
+      })
+    },
+  })
+  expect(process._internal.process).toBeDefined()
+  await expect(resolvers.listening.promise).resolves.toBeUndefined()
+  await expect(resolvers.message.promise).resolves.toBeDefined()
+  await expect(resolvers.stdout.promise).resolves.toBeDefined()
+})
+
+test('start (error)', async () => {
+  const emitter = new EventEmitter<any>()
+  const process = createProcess()
+
+  const resolvers = {
+    listening: Promise.withResolvers<void>(),
+    message: Promise.withResolvers<void>(),
+    stderr: Promise.withResolvers<void>(),
+  }
+  emitter.on('listening', resolvers.listening.resolve)
+  emitter.on('message', resolvers.message.resolve)
+  emitter.on('stderr', resolvers.stderr.resolve)
+
+  // Invalid argument
+  await expect(() =>
+    process.start(($) => $`anvil --lol`, {
+      emitter,
+      status: 'idle',
+      resolver({ process, reject, resolve }) {
+        process.stdout.on('data', (data) => {
+          const message = data.toString()
+          if (message.includes('Listening on')) resolve()
+        })
+        process.stderr.on('data', reject)
+      },
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    [Error: Failed to start process "foo": error: unexpected argument '--lol' found
+
+    Usage: anvil [OPTIONS] [COMMAND]
+
+    For more information, try '--help'.
+    ]
+  `)
+  await expect(resolvers.message.promise).resolves.toBeDefined()
+  await expect(resolvers.stderr.promise).resolves.toBeDefined()
+})
+
+test('behavior: exit', async () => {
+  const emitter = new EventEmitter<any>()
+  const process = createProcess()
+
+  const resolvers = {
+    exit: Promise.withResolvers<void>(),
+  }
+  emitter.on('exit', resolvers.exit.resolve)
+
+  // Invalid argument
+  await process.start(($) => $`anvil --port 1338`, {
+    emitter,
+    status: 'idle',
+    resolver({ process, resolve }) {
+      process.stdout.on('data', (data) => {
+        const message = data.toString()
+        if (message.includes('Listening on')) resolve()
+      })
+    },
+  })
+  process._internal.process.kill()
+  await expect(resolvers.exit.promise).resolves.toBeDefined()
+})
+
+test('behavior: exit when status is starting', async () => {
+  const emitter = new EventEmitter<any>()
+  const process = createProcess()
+
+  const resolvers = {
+    exit: Promise.withResolvers<void>(),
+  }
+  emitter.on('exit', resolvers.exit.resolve)
+
+  // Invalid argument
+  await process.start(($) => $`anvil`, {
+    emitter,
+    status: 'starting',
+    resolver({ process, resolve }) {
+      process.stdout.on('data', (data) => {
+        const message = data.toString()
+        if (message.includes('Listening on')) resolve()
+      })
+    },
+  })
+  process._internal.process.kill()
+  await expect(resolvers.exit.promise).resolves.toBeDefined()
+})

package/processes/execa.ts

@@ -0,0 +1,100 @@
+import { type ResultPromise, execa as exec } from 'execa'
+import type { InstanceStartOptions_internal } from '../instance.js'
+import { stripColors } from '../utils.js'
+
+export type Process_internal = ResultPromise<{ cleanup: true; reject: false }>
+
+export type ExecaStartOptions = InstanceStartOptions_internal & {
+  resolver(options: {
+    process: Process_internal
+    reject(data: string): Promise<void>
+    resolve(): void
+  }): void
+}
+
+export type ExecaParameters = { name: string }
+
+export type ExecaProcess = {
+  _internal: {
+    process: Process_internal
+  }
+  name: string
+  start(
+    command: (x: typeof exec) => void,
+    options: ExecaStartOptions,
+  ): Promise<void>
+  stop(): Promise<void>
+}
+export type ExecaReturnType = ExecaProcess
+
+export function execa(parameters: ExecaParameters): ExecaReturnType {
+  const { name } = parameters
+
+  let process: Process_internal
+
+  async function stop() {
+    const killed = process.kill()
+    if (!killed) return
+    return new Promise((resolve) => process.on('close', resolve))
+  }
+
+  return {
+    _internal: {
+      get process() {
+        return process
+      },
+    },
+    name,
+    start(command, { emitter, resolver, status }) {
+      const { promise, resolve, reject } = Promise.withResolvers<void>()
+
+      process = command(
+        exec({
+          cleanup: true,
+          reject: false,
+        }) as any,
+      ) as unknown as Process_internal
+
+      resolver({
+        process,
+        async reject(data) {
+          await stop()
+          reject(
+            new Error(`Failed to start process "${name}": ${data.toString()}`),
+          )
+        },
+        resolve() {
+          emitter.emit('listening')
+          return resolve()
+        },
+      })
+
+      process.stdout.on('data', (data) => {
+        const message = stripColors(data.toString())
+        emitter.emit('message', message)
+        emitter.emit('stdout', message)
+      })
+      process.stderr.on('data', async (data) => {
+        const message = stripColors(data.toString())
+        emitter.emit('message', message)
+        emitter.emit('stderr', message)
+      })
+      process.on('close', () => process.removeAllListeners())
+      process.on('exit', (code, signal) => {
+        emitter.emit('exit', code, signal)
+
+        if (!code) {
+          process.removeAllListeners()
+          if (status === 'starting')
+            reject(new Error(`Failed to start process "${name}": exited.`))
+        }
+      })
+
+      return promise
+    },
+    async stop() {
+      process.removeAllListeners()
+      await stop()
+    },
+  }
+}

package/server.test.ts

@@ -1,116 +1,123 @@
-import { describe, expect, test } from 'vitest'
+import getPort from 'get-port'
+import { beforeAll, describe, expect, test } from 'vitest'
 import { type MessageEvent, WebSocket } from 'ws'
+import { stackupOptions } from '../test/utils.js'
 import { anvil } from './instances/anvil.js'
+import { stackup } from './instances/stackup.js'
 import { createServer } from './server.js'
 
-describe.each([{ instance: anvil() }])(
-  'instance: $instance.name',
-  ({ instance }) => {
-    test('default', async () => {
-      const pool = createServer({
-        instance,
-      })
-      expect(pool).toBeDefined()
+const port = await getPort()
 
-      await pool.start()
-      expect(pool.address()).toBeDefined()
+beforeAll(() => anvil({ port }).start())
 
-      // Stop via instance method.
-      await pool.stop()
-      expect(pool.address()).toBeNull()
+describe.each([
+  { instance: anvil() },
+  {
+    instance: stackup(stackupOptions({ port })),
+  },
+])('instance: $instance.name', ({ instance }) => {
+  test('default', async () => {
+    const server = createServer({
+      instance,
+    })
+    expect(server).toBeDefined()
+
+    await server.start()
+    expect(server.address()).toBeDefined()
+
+    // Stop via instance method.
+    await server.stop()
+    expect(server.address()).toBeNull()
+
+    const stop = await server.start()
+    expect(server.address()).toBeDefined()
 
-      const stop = await pool.start()
-      expect(pool.address()).toBeDefined()
+    // Stop via return value.
+    await stop()
+    expect(server.address()).toBeNull()
+  })
 
-      // Stop via return value.
-      await stop()
-      expect(pool.address()).toBeNull()
+  test('args: port', async () => {
+    const server = createServer({
+      instance,
+      port: 3000,
     })
+    expect(server).toBeDefined()
 
-    test('args: port', async () => {
-      const pool = createServer({
-        instance,
-        port: 3000,
-      })
-      expect(pool).toBeDefined()
+    const stop = await server.start()
+    expect(server.address()?.port).toBe(3000)
+    await stop()
+  })
 
-      const stop = await pool.start()
-      expect(pool.address()?.port).toBe(3000)
-      await stop()
+  test('args: host', async () => {
+    const server = createServer({
+      instance,
+      host: 'localhost',
+      port: 3000,
     })
+    expect(server).toBeDefined()
 
-    test('args: host', async () => {
-      const pool = createServer({
-        instance,
-        host: 'localhost',
-        port: 3000,
-      })
-      expect(pool).toBeDefined()
-
-      const stop = await pool.start()
-      expect(pool.address()?.address).toBe('::1')
-      expect(pool.address()?.port).toBe(3000)
-      await stop()
+    const stop = await server.start()
+    expect(server.address()?.address).toBe('::1')
+    expect(server.address()?.port).toBe(3000)
+    await stop()
+  })
+
+  test('request: /healthcheck', async () => {
+    const server = createServer({
+      instance,
     })
 
-    test('request: /healthcheck', async () => {
-      const server = createServer({
-        instance,
-      })
+    const stop = await server.start()
+    const { port } = server.address()!
+    const response = await fetch(`http://localhost:${port}/healthcheck`)
+    expect(response.status).toBe(200)
 
-      const stop = await server.start()
-      const { port } = server.address()!
-      const response = await fetch(`http://localhost:${port}/healthcheck`)
-      expect(response.status).toBe(200)
+    await stop()
+  })
 
-      await stop()
+  test('request: /start + /stop', async () => {
+    const server = createServer({
+      instance,
     })
 
-    test('request: /start + /stop', async () => {
-      const server = createServer({
-        instance,
-      })
+    const stop = await server.start()
+    const { port } = server.address()!
+    const response = await fetch(`http://localhost:${port}/1/start`)
+    expect(response.status).toBe(200)
 
-      const stop = await server.start()
-      const { port } = server.address()!
-      const response = await fetch(`http://localhost:${port}/1/start`)
-      expect(response.status).toBe(200)
+    const json = (await response.json()) as any
+    expect(json.host).toBeDefined()
+    expect(json.port).toBeDefined()
 
-      const json = (await response.json()) as any
-      expect(json.host).toBeDefined()
-      expect(json.port).toBeDefined()
+    const response_err = await fetch(`http://localhost:${port}/1/start`)
+    expect(response_err.status).toBe(400)
+    expect(await response_err.json()).toEqual({
+      message: `Instance "${instance.name}" is not in an idle or stopped state. Status: started`,
+    })
 
-      const response_err = await fetch(`http://localhost:${port}/1/start`)
-      expect(response_err.status).toBe(400)
-      expect(await response_err.json()).toEqual({
-        message: `Instance "${instance.name}" is not in an idle or stopped state. Status: started`,
-      })
+    const response_stop = await fetch(`http://localhost:${port}/1/stop`)
+    expect(response_stop.status).toBe(200)
 
-      const response_stop = await fetch(`http://localhost:${port}/1/stop`)
-      expect(response_stop.status).toBe(200)
+    const response_2 = await fetch(`http://localhost:${port}/1/start`)
+    expect(response_2.status).toBe(200)
 
-      const response_2 = await fetch(`http://localhost:${port}/1/start`)
-      expect(response_2.status).toBe(200)
+    await stop()
+  })
 
-      await stop()
+  test('request: /restart', async () => {
+    const server = createServer({
+      instance,
     })
 
-    test('ws', async () => {
-      const server = createServer({
-        instance,
-      })
-
-      const stop = await server.start()
-      const { port } = server.address()!
-      const ws = new WebSocket(`ws://localhost:${port}/1`)
-      await new Promise((resolve) => ws.addEventListener('open', resolve))
-      ws.send('test')
-      await new Promise((resolve) => ws.addEventListener('message', resolve))
+    const stop = await server.start()
+    const { port } = server.address()!
+    const response = await fetch(`http://localhost:${port}/1/restart`)
+    expect(response.status).toBe(200)
 
-      await stop()
-    })
-  },
-)
+    await stop()
+  })
+})
 
 describe("instance: 'anvil'", () => {
   test('request: /{id}', async () => {
@@ -224,6 +231,76 @@ describe("instance: 'anvil'", () => {
     await stop()
   })
 
+  test('request: /restart', async () => {
+    const server = createServer({
+      instance: anvil(),
+    })
+
+    const stop = await server.start()
+    const { port } = server.address()!
+
+    // Mine block number
+    await fetch(`http://localhost:${port}/1`, {
+      body: JSON.stringify({
+        method: 'anvil_mine',
+        params: ['0x69', '0x0'],
+        id: 0,
+        jsonrpc: '2.0',
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      method: 'POST',
+    })
+
+    // Check block numbers
+    expect(
+      await fetch(`http://localhost:${port}/1`, {
+        body: JSON.stringify({
+          method: 'eth_blockNumber',
+          id: 0,
+          jsonrpc: '2.0',
+        }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+      }).then((x) => x.json()),
+    ).toMatchInlineSnapshot(`
+      {
+        "id": 0,
+        "jsonrpc": "2.0",
+        "result": "0x69",
+      }
+    `)
+
+    // Restart
+    await fetch(`http://localhost:${port}/1/restart`)
+
+    // Check block numbers
+    expect(
+      await fetch(`http://localhost:${port}/1`, {
+        body: JSON.stringify({
+          method: 'eth_blockNumber',
+          id: 0,
+          jsonrpc: '2.0',
+        }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+      }).then((x) => x.json()),
+    ).toMatchInlineSnapshot(`
+      {
+        "id": 0,
+        "jsonrpc": "2.0",
+        "result": "0x0",
+      }
+    `)
+
+    await stop()
+  })
+
   test('request: /messages', async () => {
     const server = createServer({
       instance: anvil(),

package/server.ts

@@ -12,7 +12,7 @@ import { extractPath } from './utils.js'
 
 const { createProxyServer } = httpProxy
 
-export type createServerParameters = DefinePoolParameters &
+export type CreateServerParameters = DefinePoolParameters<number> &
   (
     | {
         /** Host to run the server on. */
@@ -26,7 +26,7 @@ export type createServerParameters = DefinePoolParameters &
       }
   )
 
-export type createServerReturnType = Omit<
+export type CreateServerReturnType = Omit<
   Server<typeof IncomingMessage, typeof ServerResponse>,
   'address'
 > & {
@@ -36,8 +36,8 @@ export type createServerReturnType = Omit<
 }
 
 export function createServer(
-  parameters: createServerParameters,
-): createServerReturnType {
+  parameters: CreateServerParameters,
+): CreateServerReturnType {
   const { host = '::', instance, limit, port } = parameters
 
   const pool = definePool({ instance, limit })
@@ -56,44 +56,46 @@ export function createServer(
 
       const { id, path } = extractPath(url)
 
-      if (typeof id === 'number' && path === '/') {
-        const { host, port } = pool.get(id) || (await pool.start(id))
-        return proxy.web(request, response, {
-          target: `http://${host}:${port}`,
-        })
-      }
-      if (typeof id === 'number' && path === '/start') {
-        const { host, port } = await pool.start(id)
-        response
-          .writeHead(200, { 'Content-Type': 'application/json' })
-          .end(JSON.stringify({ host, port }))
-        return
-      }
-      if (typeof id === 'number' && path === '/stop') {
-        await pool.stop(id)
-        response.writeHead(200, { 'Content-Type': 'application/json' }).end()
-        return
-      }
-      if (typeof id === 'number' && path === '/messages') {
-        const messages = pool.get(id)?.messages.get() || []
-        response
-          .writeHead(200, { 'Content-Type': 'application/json' })
-          .end(JSON.stringify(messages))
-        return
+      if (typeof id === 'number') {
+        if (path === '/') {
+          const { host, port } = pool.get(id) || (await pool.start(id))
+          return proxy.web(request, response, {
+            target: `http://${host}:${port}`,
+          })
+        }
+        if (path === '/start') {
+          const { host, port } = await pool.start(id)
+          return done(response, 200, { host, port })
+        }
+        if (path === '/stop') {
+          await pool.stop(id)
+          return done(response, 200)
+        }
+        if (path === '/restart') {
+          await pool.restart(id)
+          return done(response, 200)
+        }
+        if (path === '/messages') {
+          const messages = pool.get(id)?.messages.get() || []
+          return done(response, 200, messages)
+        }
       }
 
-      if (path === '/healthcheck') {
-        response.writeHead(200, { 'Content-Type': 'application/json' }).end()
-        return
-      }
+      if (path === '/healthcheck') return done(response, 200)
 
-      response.writeHead(404, { 'Content-Type': 'application/json' }).end()
-      return
+      return done(response, 404)
     } catch (error) {
-      response
-        .writeHead(400, { 'Content-Type': 'application/json' })
-        .end(JSON.stringify({ message: (error as Error).message }))
-      return
+      return done(response, 400, { message: (error as Error).message })
+    }
+  })
+
+  proxy.on('proxyReq', (proxyReq, req) => {
+    ;(req as any)._proxyReq = proxyReq
+  })
+
+  proxy.on('error', (err, req) => {
+    if (req.socket.destroyed && (err as any).code === 'ECONNRESET') {
+      ;(req as any)._proxyReq.abort()
     }
   })
 
@@ -135,3 +137,9 @@ export function createServer(
     },
   })
 }
+
+function done(res: ServerResponse, statusCode: number, json?: unknown) {
+  return res
+    .writeHead(statusCode, { 'Content-Type': 'application/json' })
+    .end(json ? JSON.stringify(json) : undefined)
+}