prool 0.0.4 → 0.0.5

package/pool.test.ts

@@ -1,9 +1,15 @@
 import getPort from 'get-port'
-import { afterEach, describe, expect, test } from 'vitest'
+import { afterEach, beforeAll, describe, expect, test } from 'vitest'
+
+import { stackupOptions } from '../test/utils.js'
 import { anvil } from './instances/anvil.js'
+import { stackup } from './instances/stackup.js'
 import { definePool } from './pool.js'
 
 let pool: ReturnType<typeof definePool>
+const port = await getPort()
+
+beforeAll(() => anvil({ port }).start())
 
 afterEach(async () => {
   try {
@@ -13,238 +19,256 @@ afterEach(async () => {
   }
 })
 
-describe.each([{ instance: anvil() }])(
-  'instance: $instance.name',
-  ({ instance }) => {
-    test('default', async () => {
-      pool = definePool({
-        instance,
-      })
+describe.each([
+  { instance: anvil() },
+  {
+    instance: stackup(stackupOptions({ port })),
+  },
+])('instance: $instance.name', ({ instance }) => {
+  test('default', async () => {
+    pool = definePool({
+      instance,
+    })
+
+    expect(pool).toBeDefined()
+  })
 
-      expect(pool).toBeDefined()
+  test('start', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('start', async () => {
-      pool = definePool({
-        instance,
-      })
+    expect(pool.size).toEqual(0)
+
+    const instance_1 = await pool.start(1)
+    expect(instance_1.status).toBe('started')
+    expect(pool.size).toEqual(1)
+
+    const instance_2 = await pool.start(2)
+    expect(instance_2.status).toBe('started')
+    expect(pool.size).toEqual(2)
+
+    const instance_3 = await pool.start(1337)
+    expect(instance_3.status).toBe('started')
+    expect(pool.size).toEqual(3)
+  })
 
-      expect(pool.size).toEqual(0)
+  test('callback instance', async () => {
+    const keys: (number | string)[] = []
+    pool = definePool({
+      instance(key) {
+        keys.push(key)
+        return instance
+      },
+    })
 
-      const instance_1 = await pool.start(1)
-      expect(instance_1.status).toBe('started')
-      expect(pool.size).toEqual(1)
+    await pool.start(1)
+    await pool.start(2)
+    await pool.start(1337)
 
-      const instance_2 = await pool.start(2)
-      expect(instance_2.status).toBe('started')
-      expect(pool.size).toEqual(2)
+    expect(keys).toStrictEqual([1, 2, 1337])
+  })
 
-      const instance_3 = await pool.start(1337)
-      expect(instance_3.status).toBe('started')
-      expect(pool.size).toEqual(3)
+  test('stop / destroy', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('stop / destroy', async () => {
-      pool = definePool({
-        instance,
-      })
+    const instance_1 = await pool.start(1)
+    const instance_2 = await pool.start(2)
+    const instance_3 = await pool.start(3)
 
-      const instance_1 = await pool.start(1)
-      const instance_2 = await pool.start(2)
-      const instance_3 = await pool.start(3)
+    expect(instance_1.status).toBe('started')
+    expect(instance_2.status).toBe('started')
+    expect(instance_3.status).toBe('started')
+    expect(pool.size).toEqual(3)
 
-      expect(instance_1.status).toBe('started')
-      expect(instance_2.status).toBe('started')
-      expect(instance_3.status).toBe('started')
-      expect(pool.size).toEqual(3)
+    await pool.stop(1)
+    expect(instance_1.status).toBe('stopped')
 
-      await pool.stop(1)
-      expect(instance_1.status).toBe('stopped')
+    await pool.stop(2)
+    expect(instance_2.status).toBe('stopped')
 
-      await pool.stop(2)
-      expect(instance_2.status).toBe('stopped')
+    await pool.stop(3)
+    expect(instance_3.status).toBe('stopped')
 
-      await pool.stop(3)
-      expect(instance_3.status).toBe('stopped')
+    await pool.stop(1)
+    await pool.stop(2)
+    await pool.stop(3)
+    await pool.stop(4)
 
-      await pool.stop(1)
-      await pool.stop(2)
-      await pool.stop(3)
-      await pool.stop(4)
+    expect(pool.size).toEqual(3)
 
-      expect(pool.size).toEqual(3)
+    await pool.destroy(1)
+    expect(pool.size).toEqual(2)
+    await pool.destroy(2)
+    expect(pool.size).toEqual(1)
+    await pool.destroy(3)
+    expect(pool.size).toEqual(0)
+  })
 
-      await pool.destroy(1)
-      expect(pool.size).toEqual(2)
-      await pool.destroy(2)
-      expect(pool.size).toEqual(1)
-      await pool.destroy(3)
-      expect(pool.size).toEqual(0)
+  test('restart', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('restart', async () => {
-      pool = definePool({
-        instance,
-      })
+    const instance_1 = await pool.start(1)
+    const instance_2 = await pool.start(2)
+    const instance_3 = await pool.start(3)
 
-      const instance_1 = await pool.start(1)
-      const instance_2 = await pool.start(2)
-      const instance_3 = await pool.start(3)
+    expect(instance_1.status).toBe('started')
+    expect(instance_2.status).toBe('started')
+    expect(instance_3.status).toBe('started')
+    expect(pool.size).toEqual(3)
 
-      expect(instance_1.status).toBe('started')
-      expect(instance_2.status).toBe('started')
-      expect(instance_3.status).toBe('started')
-      expect(pool.size).toEqual(3)
+    const promise_1 = pool.restart(1)
+    expect(instance_1.status).toBe('restarting')
+    await promise_1
+    expect(instance_1.status).toBe('started')
+  })
 
-      const promise_1 = pool.restart(1)
-      expect(instance_1.status).toBe('restarting')
-      await promise_1
-      expect(instance_1.status).toBe('started')
+  test('start > stop > start', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('start > stop > start', async () => {
-      pool = definePool({
-        instance,
-      })
+    const instance_1 = await pool.start(1)
+    expect(instance_1.status).toBe('started')
 
-      const instance_1 = await pool.start(1)
-      expect(instance_1.status).toBe('started')
+    await pool.stop(1)
+    expect(instance_1.status).toBe('stopped')
 
-      await pool.stop(1)
-      expect(instance_1.status).toBe('stopped')
+    await pool.start(1)
+    expect(instance_1.status).toBe('started')
+  })
 
-      await pool.start(1)
-      expect(instance_1.status).toBe('started')
+  test('stopAll / destroyAll', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('stopAll / destroyAll', async () => {
-      pool = definePool({
-        instance,
-      })
+    await pool.start(1)
+    await pool.start(2)
+    await pool.start(3)
 
-      await pool.start(1)
-      await pool.start(2)
-      await pool.start(3)
+    expect(pool.size).toEqual(3)
 
-      expect(pool.size).toEqual(3)
+    await pool.stopAll()
+    expect(pool.size).toEqual(3)
 
-      await pool.stopAll()
-      expect(pool.size).toEqual(3)
+    await pool.destroyAll()
+    expect(pool.size).toEqual(0)
+  })
 
-      await pool.destroyAll()
-      expect(pool.size).toEqual(0)
+  test('get', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('get', async () => {
-      pool = definePool({
-        instance,
-      })
+    const instance_1 = await pool.start(1)
+    const instance_2 = await pool.start(2)
+    const instance_3 = await pool.start(3)
 
-      const instance_1 = await pool.start(1)
-      const instance_2 = await pool.start(2)
-      const instance_3 = await pool.start(3)
+    expect(pool.get(1)).toStrictEqual(instance_1)
+    expect(pool.get(2)).toStrictEqual(instance_2)
+    expect(pool.get(3)).toStrictEqual(instance_3)
+  })
 
-      expect(pool.get(1)).toStrictEqual(instance_1)
-      expect(pool.get(2)).toStrictEqual(instance_2)
-      expect(pool.get(3)).toStrictEqual(instance_3)
+  test('behavior: start more than once', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('behavior: start more than once', async () => {
-      pool = definePool({
-        instance,
-      })
+    const promise_1 = pool.start(1)
+    const promise_2 = pool.start(1)
+    expect(promise_1).toStrictEqual(promise_2)
 
-      const promise_1 = pool.start(1)
-      const promise_2 = pool.start(1)
-      expect(promise_1).toStrictEqual(promise_2)
+    const instance_1 = await promise_1
+    const instance_2 = await promise_2
+    expect(instance_1).toStrictEqual(instance_2)
+  })
 
-      const instance_1 = await promise_1
-      const instance_2 = await promise_2
-      expect(instance_1).toStrictEqual(instance_2)
+  test('behavior: clear more than once', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('behavior: clear more than once', async () => {
-      pool = definePool({
-        instance,
-      })
+    await pool.start(1)
+    await pool.start(2)
+    await pool.start(3)
 
-      await pool.start(1)
-      await pool.start(2)
-      await pool.start(3)
+    const promise_1 = pool.stopAll()
+    const promise_2 = pool.stopAll()
+    expect(promise_1).toStrictEqual(promise_2)
 
-      const promise_1 = pool.stopAll()
-      const promise_2 = pool.stopAll()
-      expect(promise_1).toStrictEqual(promise_2)
+    await promise_1
+    await promise_2
+  })
 
-      await promise_1
-      await promise_2
+  test('behavior: restart more than once', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('behavior: restart more than once', async () => {
-      pool = definePool({
-        instance,
-      })
+    const instance_1 = await pool.start(1)
+    expect(instance_1.status).toBe('started')
 
-      const instance_1 = await pool.start(1)
-      expect(instance_1.status).toBe('started')
+    const promise_1 = pool.restart(1)
+    expect(instance_1.status).toBe('restarting')
+    const promise_2 = pool.restart(1)
+    expect(instance_1.status).toBe('restarting')
 
-      const promise_1 = pool.restart(1)
-      expect(instance_1.status).toBe('restarting')
-      const promise_2 = pool.restart(1)
-      expect(instance_1.status).toBe('restarting')
+    expect(promise_1).toStrictEqual(promise_2)
 
-      expect(promise_1).toStrictEqual(promise_2)
+    await promise_1
+    expect(instance_1.status).toBe('started')
+    await promise_2
+    expect(instance_1.status).toBe('started')
+  })
 
-      await promise_1
-      expect(instance_1.status).toBe('started')
-      await promise_2
-      expect(instance_1.status).toBe('started')
+  test('behavior: stop more than once', async () => {
+    pool = definePool({
+      instance,
     })
 
-    test('behavior: stop more than once', async () => {
-      pool = definePool({
-        instance,
-      })
+    await pool.start(1)
 
-      await pool.start(1)
+    const promise_1 = pool.stop(1)
+    const promise_2 = pool.stop(1)
+    expect(promise_1).toStrictEqual(promise_2)
 
-      const promise_1 = pool.stop(1)
-      const promise_2 = pool.stop(1)
-      expect(promise_1).toStrictEqual(promise_2)
+    await promise_1
+    await promise_2
+  })
 
-      await promise_1
-      await promise_2
-    })
+  test('error: start more than once on same port', async () => {
+    const port = await getPort()
 
-    test('error: start more than once on same port', async () => {
-      const port = await getPort()
+    pool = definePool({
+      instance,
+    })
 
-      pool = definePool({
-        instance,
-      })
+    await pool.start(1, { port })
 
-      await pool.start(1, { port })
+    const promise_1 = pool.start(2, { port })
+    const promise_2 = pool.start(2, { port })
+    expect(promise_1).toStrictEqual(promise_2)
 
-      const promise_1 = pool.start(2, { port })
-      const promise_2 = pool.start(2, { port })
-      expect(promise_1).toStrictEqual(promise_2)
+    await expect(() => promise_1).rejects.toThrowError()
+    await expect(() => promise_2).rejects.toThrowError()
+  })
 
-      await expect(() => promise_1).rejects.toThrowError()
-      await expect(() => promise_2).rejects.toThrowError()
+  test('error: instance limit reached', async () => {
+    pool = definePool({
+      instance,
+      limit: 2,
     })
 
-    test('error: instance limit reached', async () => {
-      pool = definePool({
-        instance,
-        limit: 2,
-      })
+    await pool.start(1)
+    await pool.start(2)
 
-      await pool.start(1)
-      await pool.start(2)
-
-      await expect(() => pool.start(3)).rejects.toThrowError(
-        'Instance limit of 2 reached.',
-      )
-    })
-  },
-)
+    await expect(() => pool.start(3)).rejects.toThrowError(
+      'Instance limit of 2 reached.',
+    )
+  })
+})

package/pool.ts

@@ -4,12 +4,12 @@ import type { Instance } from './instance.js'
 
 type Instance_ = Omit<Instance, 'create'>
 
-export type Pool<key = number> = Pick<
+export type Pool<key extends number | string = number | string> = Pick<
   Map<key, Instance_>,
   'entries' | 'keys' | 'forEach' | 'get' | 'has' | 'size' | 'values'
 > & {
   _internal: {
-    instance: Instance_
+    instance: Instance_ | ((key: key) => Instance_)
   }
   destroy(key: key): Promise<void>
   destroyAll(): Promise<void>
@@ -19,14 +19,18 @@ export type Pool<key = number> = Pick<
   stopAll(): Promise<void>
 }
 
-export type DefinePoolParameters = {
+export type DefinePoolParameters<
+  key extends number | string = number | string,
+> = {
   /** Instance for the pool. */
-  instance: Instance
+  instance: Instance | ((key: key) => Instance)
   /** The maximum number of instances that can be started. */
   limit?: number | number
 }
 
-export type DefinePoolReturnType<key = number> = Pool<key>
+export type DefinePoolReturnType<
+  key extends number | string = number | string,
+> = Pool<key>
 
 /**
  * Defines an instance pool. Instances can be started, cached, and stopped against an identifier.
@@ -42,10 +46,10 @@ export type DefinePoolReturnType<key = number> = Pool<key>
  * const instance_3 = await pool.start(3)
  * ```
  */
-export function definePool<key = number>(
-  parameters: DefinePoolParameters,
+export function definePool<key extends number | string = number>(
+  parameters: DefinePoolParameters<key>,
 ): DefinePoolReturnType<key> {
-  const { instance, limit } = parameters
+  const { limit } = parameters
 
   type Instance_ = Omit<Instance, 'create'>
   const instances = new Map<key, Instance_>()
@@ -65,7 +69,7 @@ export function definePool<key = number>(
 
   return {
     _internal: {
-      instance,
+      instance: parameters.instance,
     },
     async destroy(key) {
       const destroyPromise = promises.destroy.get(key)
@@ -130,7 +134,12 @@ export function definePool<key = number>(
 
       promises.start.set(key, resolver.promise)
 
+      const instance =
+        typeof parameters.instance === 'function'
+          ? parameters.instance(key)
+          : parameters.instance
       const { port = await getPort() } = options
+
       const instance_ = instances.get(key) || instance.create({ port })
       instance_
         .start()

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()
+})