@xylabs/threads 4.6.4 → 4.7.0

package/test/observable-promise.test.ts

@@ -1,205 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { Observable } from 'observable-fns'
-import { expect, test } from 'vitest'
-
-import { ObservablePromise } from '../src/observable-promise'
-
-const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-
-test('can create an observable promise', async () => {
-  expect.assertions(1)
-
-  await new ObservablePromise((observer) => {
-    expect(true).toBe(true)
-    observer.complete()
-  })
-})
-
-test('init function is only called once', async () => {
-  let initCallCount = 0
-
-  const async = new ObservablePromise((observer) => {
-    initCallCount++
-    setTimeout(() => observer.complete(), 10)
-  })
-
-  await Promise.all([
-    async.then(() => expect(true).toBe(true)),
-    async.then(() => expect(true).toBe(true)),
-    async.then(() => expect(true).toBe(true)),
-  ])
-
-  expect(initCallCount).toBe(1)
-})
-
-test('can proxy a promise fulfillment', async () => {
-  expect.assertions(2) // Ensure two assertions are made
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => {
-      observer.next(123)
-
-      // Ignore all values after the first one
-      observer.next(456)
-      observer.complete()
-    }, 1)
-  })
-
-  const promise1 = async.then(
-    value => expect(value).toBe(123),
-    () => expect.fail('Promise was rejected unexpectedly'),
-  )
-
-  await delay(10)
-
-  const promise2 = async.then(
-    value => expect(value).toBe(123),
-    () => expect.fail('Promise was rejected unexpectedly'),
-  )
-
-  await Promise.all([promise1, promise2])
-})
-
-test('can proxy a promise rejection', async () => {
-  let handlerCallCount = 0
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => observer.error(new Error('I am supposed to be rejected.')), 1)
-  })
-
-  const promise1 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await delay(10)
-
-  const promise2 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await Promise.all([promise1.catch(() => true), promise2.catch(() => true)])
-  expect(handlerCallCount).toBe(2)
-})
-
-test('can proxy a promise rejection caused by a sync throw', async () => {
-  let handlerCallCount = 0
-
-  const async = new ObservablePromise(() => {
-    throw new Error('I am supposed to be rejected.')
-  })
-
-  const promise1 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await delay(10)
-
-  const promise2 = async.then(
-    () => expect.fail('Promise should not become fulfilled'),
-    () => handlerCallCount++,
-  )
-
-  await Promise.all([promise1.catch(() => true), promise2.catch(() => true)])
-  expect(handlerCallCount).toBe(2)
-})
-
-test('can subscribe to values and completion', async () => {
-  const capturedValues: any[] = []
-  let capturedCompletions = 0
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => observer.next(1), 10)
-    setTimeout(() => observer.next(2), 20)
-    setTimeout(() => observer.complete(), 30)
-  })
-
-  for (let index = 0; index < 2; index++) {
-    async.subscribe(
-      value => capturedValues.push(value),
-      () => {},
-      () => capturedCompletions++,
-    )
-  }
-
-  await async.finally()
-  await delay(1)
-
-  expect(capturedValues).toEqual([1, 1, 2, 2])
-  expect(capturedCompletions).toBe(2)
-})
-
-test('can subscribe to errors', async () => {
-  const capturedErrorMessages: string[] = []
-  const capturedValues: any[] = []
-  let capturedCompletions = 0
-
-  const async = new ObservablePromise((observer) => {
-    setTimeout(() => observer.next(1), 10)
-    setTimeout(() => observer.error(new Error('Fails as expected.')), 20)
-    setTimeout(() => observer.next(2), 30) // This won't be called due to error
-    setTimeout(() => observer.complete(), 40) // This also won't be called
-  })
-
-  for (let index = 0; index < 2; index++) {
-    async.subscribe(
-      value => capturedValues.push(value),
-      error => capturedErrorMessages.push(error.message),
-      () => capturedCompletions++,
-    )
-  }
-
-  await async.finally()
-  await delay(35) // Wait to ensure the error and all async events are captured
-
-  expect(capturedValues).toEqual([1, 1])
-  expect(capturedErrorMessages).toEqual(['Fails as expected.', 'Fails as expected.'])
-  expect(capturedCompletions).toBe(0)
-})
-
-test('from(Observable) works', async () => {
-  const capturedErrorMessages: string[] = []
-  const capturedValues: any[] = []
-  let capturedCompletions = 0
-
-  const async = ObservablePromise.from(
-    new Observable((observer) => {
-      setTimeout(() => observer.next(1), 10)
-      setTimeout(() => observer.error(new Error('Fails as expected.')), 20)
-      setTimeout(() => observer.next(2), 30) // This won't be called due to error
-      setTimeout(() => observer.complete(), 40) // This also won't be called
-    }),
-  )
-
-  for (let index = 0; index < 2; index++) {
-    async.subscribe(
-      value => capturedValues.push(value),
-      error => capturedErrorMessages.push(error.message),
-      () => capturedCompletions++,
-    )
-  }
-
-  await async.finally()
-  await delay(35) // Allow time for error and async processing
-
-  expect(capturedValues).toEqual([1, 1])
-  expect(capturedErrorMessages).toEqual(['Fails as expected.', 'Fails as expected.'])
-  expect(capturedCompletions).toBe(0)
-})
-
-test('from(Promise) works', async () => {
-  const resolved = ObservablePromise.from(
-    new Promise((resolve) => {
-      setTimeout(() => resolve('Works'), 10)
-    }),
-  )
-
-  await expect(resolved).resolves.toBe('Works')
-
-  const rejected = ObservablePromise.from(Promise.reject(new Error('Fails')))
-  await expect(rejected).rejects.toThrow('Fails')
-})

package/test/observable.test.ts

@@ -1,87 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable require-await */
-
-import { expect, test } from 'vitest'
-
-import { Observable, Subject } from '../src/observable'
-
-test('Observable subject emits values and completion event', async () => {
-  let completed1 = false
-  const values1: number[] = []
-  let completed2 = false
-  const values2: number[] = []
-  let completed3 = false
-  const values3: number[] = []
-
-  const subject = new Subject<number>()
-  const observable = Observable.from(subject)
-
-  const subscription1 = subject.subscribe(
-    value => values1.push(value),
-    undefined,
-    () => (completed1 = false),
-  )
-  subject.subscribe(
-    value => values2.push(value),
-    undefined,
-    () => (completed2 = true),
-  )
-  observable.subscribe(
-    value => values3.push(value),
-    undefined,
-    () => (completed3 = true),
-  )
-
-  subject.next(1)
-  subscription1.unsubscribe()
-
-  subject.next(2)
-  subject.complete()
-
-  expect(values1).toEqual([1])
-  expect(values2).toEqual([1, 2])
-  expect(values3).toEqual([1, 2])
-  expect(completed1).toBe(false)
-  expect(completed2).toBe(true)
-  expect(completed3).toBe(true)
-})
-
-test('Observable subject propagates errors', async () => {
-  let completed1 = false
-  let error1: Error | undefined
-  let completed2 = false
-  let error2: Error | undefined
-  let completed3 = false
-  let error3: Error | undefined
-
-  const subject = new Subject<number>()
-  const observable = Observable.from(subject)
-
-  const subscription1 = subject.subscribe(
-    () => {},
-    error => (error1 = error),
-    () => (completed1 = true),
-  )
-  subject.subscribe(
-    () => {},
-    error => (error2 = error),
-    () => (completed2 = true),
-  )
-  observable.subscribe(
-    () => {},
-    error => (error3 = error),
-    () => (completed3 = true),
-  )
-
-  const testingError = new Error('Test, test!')
-
-  subscription1.unsubscribe()
-  subject.error(testingError)
-
-  expect(completed1).toBe(false)
-  expect(error1).toBeUndefined()
-  expect(completed2).toBe(false)
-  expect(error2).toBe(testingError)
-  expect(completed3).toBe(false)
-  expect(error3).toBe(testingError)
-})

package/test/pool.test.ts

@@ -1,183 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-
-/* eslint-disable require-await */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-// eslint-disable import-x/no-internal-modules
-import { expect, test } from 'vitest'
-
-import type { FunctionThread } from '../src/index'
-import {
-  Pool, spawn, Worker,
-} from '../src/index'
-import type { PoolEvent, QueuedTask } from '../src/master/pool'
-import { PoolEventType } from '../src/master/pool'
-
-const workerPath = './workers/hello-world.ts'
-const HELLO_WORLD = 'Hello World'
-
-test('thread pool basics work and events are emitted', async () => {
-  const events: Pool.Event[] = []
-  let spawnCalled = 0
-  let taskFnCalled = 0
-
-  const spawnHelloWorld = () => {
-    spawnCalled++
-    return spawn<() => string>(new Worker(workerPath))
-  }
-
-  const pool = Pool(spawnHelloWorld, 3)
-  pool.events().subscribe(event => events.push(event))
-
-  // Ensure all worker threads are initialized before starting to queue tasks
-  await new Promise<PoolEvent<FunctionThread<[], string>>>((resolve, reject) => {
-    pool
-      .events()
-      .filter(event => event.type === Pool.EventType.initialized)
-      .subscribe(resolve, reject)
-  })
-
-  await pool.queue(async (helloWorld) => {
-    taskFnCalled++
-    const result = await helloWorld()
-    expect(result).toBe(HELLO_WORLD)
-    return result
-  })
-
-  await pool.terminate()
-
-  expect(spawnCalled).toBe(3)
-  expect(taskFnCalled).toBe(1)
-
-  expect(events).toEqual([
-    {
-      size: 3,
-      type: Pool.EventType.initialized,
-    },
-    {
-      taskID: 1,
-      type: Pool.EventType.taskQueued,
-    },
-    {
-      taskID: 1,
-      type: Pool.EventType.taskStart,
-      workerID: 1,
-    },
-    {
-      returnValue: HELLO_WORLD,
-      taskID: 1,
-      type: Pool.EventType.taskCompleted,
-      workerID: 1,
-    },
-    { type: Pool.EventType.taskQueueDrained },
-    {
-      remainingQueue: [],
-      type: Pool.EventType.terminated,
-    },
-  ])
-})
-
-test('pool.completed() works', async () => {
-  const returned: any[] = []
-
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  for (let i = 0; i < 3; i++) {
-    pool.queue(async (helloWorld) => {
-      returned.push(await helloWorld())
-    })
-  }
-
-  await pool.completed()
-
-  expect(returned).toEqual([HELLO_WORLD, HELLO_WORLD, HELLO_WORLD])
-})
-
-test('pool.completed() proxies errors', async () => {
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  pool.queue(async () => {
-    throw new Error('Ooopsie')
-  })
-
-  await expect(pool.completed()).rejects.toThrow('Ooopsie')
-})
-
-test('pool.completed(true) works', async () => {
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  await pool.completed(true)
-
-  expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-})
-
-test('pool.settled() does not reject on task failure', async () => {
-  const returned: any[] = []
-
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  pool.queue(async (helloWorld) => {
-    returned.push(await helloWorld())
-  })
-  pool.queue(async () => {
-    throw new Error('Test error one')
-  })
-  pool.queue(async () => {
-    throw new Error('Test error two')
-  })
-
-  const errors = await pool.settled()
-
-  expect(errors.length).toBe(2)
-  expect(errors.map(error => error.message).sort()).toEqual(['Test error one', 'Test error two'])
-})
-
-test('pool.settled(true) works', async () => {
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 2)
-
-  await pool.settled(true)
-
-  expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-})
-
-test('task.cancel() works', async () => {
-  const events: Pool.Event[] = []
-  const spawnHelloWorld = () => spawn(new Worker(workerPath))
-  const pool = Pool(spawnHelloWorld, 1)
-
-  pool.events().subscribe(event => events.push(event))
-
-  let executionCount = 0
-  const tasks: QueuedTask<any, any>[] = []
-
-  for (let i = 0; i < 4; i++) {
-    const task = pool.queue((helloWorld) => {
-      executionCount++
-      return helloWorld()
-    })
-    tasks.push(task)
-  }
-
-  tasks[2].cancel()
-  tasks[3].cancel()
-
-  await pool.completed()
-  expect(executionCount).toBe(2)
-
-  const cancellationEvents = events.filter(event => event.type === PoolEventType.taskCanceled)
-  expect(cancellationEvents).toEqual([
-    {
-      taskID: 3,
-      type: PoolEventType.taskCanceled,
-    },
-    {
-      taskID: 4,
-      type: PoolEventType.taskCanceled,
-    },
-  ])
-})

package/test/serialization.test.ts

@@ -1,23 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-import { expect, test } from 'vitest'
-
-import {
-  registerSerializer, spawn, Thread, Worker,
-} from '../src/index'
-import { Foo, fooSerializer } from './lib/serialization'
-
-registerSerializer(fooSerializer)
-
-test('can use a custom serializer', async () => {
-  const run = await spawn(new Worker('./workers/serialization.ts'))
-
-  try {
-    const input = new Foo('Test')
-    const result: Foo<string> = await run(input)
-
-    expect(result).toBeInstanceOf(Foo)
-    expect(result.getValue()).toBe('TestTest')
-  } finally {
-    await Thread.terminate(run)
-  }
-})

package/test/spawn.chromium.mocha.ts

@@ -1,53 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-/* eslint-disable no-restricted-imports */
-/*
- * This code here will be run in a headless Chromium browser using `puppet-run`.
- * Check the package.json scripts `test:puppeteer:*`.
- */
-
-// We need this as a work-around to make our threads Worker global, since
-// the bundler would otherwise not recognize `new Worker()` as a web worker
-import '../src/master/register'
-
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import {
-  BlobWorker, spawn, Thread,
-} from '..'
-
-describe('threads in browser', function () {
-  it('can spawn and terminate a thread', async function () {
-    const helloWorld = await spawn<() => string>(new Worker('./workers/hello-world.ts'))
-    expect(await helloWorld()).to.equal('Hello World')
-    await Thread.terminate(helloWorld)
-  })
-
-  it('can call a function thread more than once', async function () {
-    const increment = await spawn<() => number>(new Worker('./workers/increment.ts'))
-    expect(await increment()).to.equal(1)
-    expect(await increment()).to.equal(2)
-    expect(await increment()).to.equal(3)
-    await Thread.terminate(increment)
-  })
-
-  it('can spawn and use a blob worker', async function () {
-    const baseUrl = new URL(globalThis.location.href).origin
-    const workerSource = `
-      // Makes expose() available on global scope
-      importScripts(${JSON.stringify(baseUrl + '/worker.js')})
-
-      let counter = 0
-
-      expose(function() {
-        return ++counter
-      })
-    `
-    const increment = await spawn<() => number>(BlobWorker.fromText(workerSource))
-    expect(await increment()).to.equal(1)
-    expect(await increment()).to.equal(2)
-    expect(await increment()).to.equal(3)
-    await Thread.terminate(increment)
-  })
-})

package/test/spawn.test.ts

@@ -1,87 +0,0 @@
-/* eslint-disable import-x/no-internal-modules */
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { builtinModules } from 'node:module'
-
-import type { Observable } from 'observable-fns'
-import { expect, test } from 'vitest'
-
-import {
-  spawn, Thread, Worker,
-} from '../src/index'
-import type { Counter } from './workers/counter.ts'
-
-test('can spawn and terminate a thread', async () => {
-  // We also test here that running spawn() without type parameters works
-  const helloWorld = await spawn(new Worker('./workers/hello-world.ts'))
-
-  expect(await helloWorld()).toBe('Hello World')
-  await Thread.terminate(helloWorld)
-
-  expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-})
-
-test('can call a function thread more than once', async () => {
-  const increment = await spawn<() => number>(new Worker('./workers/increment.ts'))
-
-  expect(await increment()).toBe(1)
-  expect(await increment()).toBe(2)
-  expect(await increment()).toBe(3)
-
-  await Thread.terminate(increment)
-})
-
-test('can subscribe to an observable returned by a thread call', async () => {
-  const countToFive = await spawn<() => Observable<number>>(new Worker('./workers/count-to-five.ts'))
-  const encounteredValues: any[] = []
-
-  const observable = countToFive()
-  observable.subscribe(value => encounteredValues.push(value))
-  await observable
-
-  expect(encounteredValues).toEqual([1, 2, 3, 4, 5])
-  await Thread.terminate(countToFive)
-})
-
-test('can spawn a module thread', async () => {
-  const counter = await spawn<Counter>(new Worker('./workers/counter.ts'))
-
-  expect(await counter.getCount()).toBe(0)
-
-  await Promise.all([counter.increment(), counter.increment()])
-  expect(await counter.getCount()).toBe(2)
-
-  await counter.decrement()
-  expect(await counter.getCount()).toBe(1)
-
-  await Thread.terminate(counter)
-})
-
-test('thread job errors are handled', async () => {
-  const fail = await spawn<() => Promise<never>>(new Worker('./workers/faulty-function.ts'))
-
-  await expect(fail()).rejects.toThrow('I am supposed to fail.')
-
-  await Thread.terminate(fail)
-})
-
-test('thread transfer errors are handled', async () => {
-  if (builtinModules.includes('worker_threads')) {
-    // Test is applicable only for native worker_threads
-    const helloWorld = await spawn(new Worker('./workers/hello-world.ts'))
-    const badTransferObj = { fn: () => {} }
-
-    await expect(helloWorld(badTransferObj)).rejects.toThrow()
-
-    await Thread.terminate(helloWorld)
-  } else {
-    expect(true).toBe(true) // Equivalent to t.pass() in Vitest
-  }
-})
-
-/* test('catches top-level thread errors', async () => {
-  await expect(spawn(new Worker('./workers/top-level-throw.ts'))).rejects.toThrow()
-}) */
-
-test.todo('can subscribe to thread events')

package/test/streaming.test.ts

@@ -1,29 +0,0 @@
-import { expect, test } from 'vitest'
-
-import {
-  spawn, Thread, Worker,
-} from '../src/index'
-
-test('can use worker returning an observable subject', async () => {
-  const captured: Array<{ max: number; min: number }> = []
-
-  const minmax = await spawn(new Worker('./workers/minmax.ts'))
-  minmax.values().subscribe(values => captured.push(values))
-
-  await minmax.push(2)
-  await minmax.push(3)
-  await minmax.push(4)
-  await minmax.push(1)
-  await minmax.push(5)
-  await minmax.finish()
-
-  await Thread.terminate(minmax)
-
-  expect(captured).toEqual([
-    { max: 2, min: 2 },
-    { max: 3, min: 2 },
-    { max: 4, min: 2 },
-    { max: 4, min: 1 },
-    { max: 5, min: 1 },
-  ])
-})