| import { afterEach, describe, expect, it } from 'vitest'; |
|
|
| import { Disposable, DisposableStore, type IDisposable } from '#/_base/di/lifecycle'; |
| import { Emitter, Event } from '#/_base/event'; |
| import { |
| resetUnexpectedErrorHandler, |
| setUnexpectedErrorHandler, |
| } from '#/_base/errors/unexpectedError'; |
|
|
| afterEach(() => { |
| resetUnexpectedErrorHandler(); |
| }); |
|
|
| function captureThrown(fn: () => void): unknown { |
| try { |
| fn(); |
| return undefined; |
| } catch (error) { |
| return error; |
| } |
| } |
|
|
| describe('Emitter / Event', () => { |
| it('fire delivers to all listeners in subscribe order', () => { |
| const emitter = new Emitter<number>(); |
| const seen: string[] = []; |
| emitter.event((value) => seen.push(`a:${value}`)); |
| emitter.event((value) => seen.push(`b:${value}`)); |
| emitter.event((value) => seen.push(`c:${value}`)); |
|
|
| emitter.fire(1); |
| emitter.fire(2); |
|
|
| expect(seen).toEqual(['a:1', 'b:1', 'c:1', 'a:2', 'b:2', 'c:2']); |
| emitter.dispose(); |
| }); |
|
|
| it('returned IDisposable removes the listener', () => { |
| const emitter = new Emitter<number>(); |
| const seen: number[] = []; |
| const subscription = emitter.event((value) => seen.push(value)); |
|
|
| emitter.fire(1); |
| subscription.dispose(); |
| emitter.fire(2); |
|
|
| expect(seen).toEqual([1]); |
| emitter.dispose(); |
| }); |
|
|
| it('binds thisArg so the listener sees the supplied context', () => { |
| const emitter = new Emitter<string>(); |
| const context = { tag: 'ctx', got: [] as string[] }; |
|
|
| emitter.event( |
| function (this: typeof context, value: string) { |
| this.got.push(value); |
| }, |
| context, |
| ); |
| emitter.fire('hello'); |
|
|
| expect(context.got).toEqual(['hello']); |
| emitter.dispose(); |
| }); |
|
|
| it('listener exception routes to onUnexpectedError and does not skip siblings', () => { |
| const captured: unknown[] = []; |
| setUnexpectedErrorHandler((error) => captured.push(error)); |
| const emitter = new Emitter<number>(); |
| const seen: string[] = []; |
| emitter.event(() => { |
| seen.push('a'); |
| }); |
| emitter.event(() => { |
| throw new Error('listener-boom'); |
| }); |
| emitter.event(() => { |
| seen.push('c'); |
| }); |
|
|
| emitter.fire(1); |
|
|
| expect(seen).toEqual(['a', 'c']); |
| expect(captured).toHaveLength(1); |
| expect((captured[0] as Error).message).toBe('listener-boom'); |
| emitter.dispose(); |
| }); |
|
|
| it('dispose makes fire a no-op and event subscribe returns Disposable.None', () => { |
| const emitter = new Emitter<number>(); |
| const seen: number[] = []; |
| emitter.event((value) => seen.push(value)); |
|
|
| emitter.dispose(); |
| emitter.fire(1); |
| const subscription = emitter.event((value) => seen.push(value)); |
| emitter.fire(2); |
|
|
| expect(seen).toEqual([]); |
| expect(subscription).toBe(Disposable.None); |
| expect(() => subscription.dispose()).not.toThrow(); |
| }); |
|
|
| it('disposables array overload collects the subscription disposable', () => { |
| const emitter = new Emitter<number>(); |
| const bag: IDisposable[] = []; |
|
|
| emitter.event(() => undefined, undefined, bag); |
|
|
| expect(bag).toHaveLength(1); |
| emitter.dispose(); |
| }); |
|
|
| it('disposables DisposableStore overload collects the subscription disposable', () => { |
| const emitter = new Emitter<number>(); |
| const store = new DisposableStore(); |
| const seen: number[] = []; |
|
|
| emitter.event((value) => seen.push(value), undefined, store); |
| emitter.fire(1); |
| store.dispose(); |
| emitter.fire(2); |
|
|
| expect(seen).toEqual([1]); |
| emitter.dispose(); |
| }); |
|
|
| it('listener added during fire does not receive the in-flight value', () => { |
| const emitter = new Emitter<number>(); |
| const seen: string[] = []; |
| emitter.event(() => { |
| seen.push('a'); |
| emitter.event(() => seen.push('late')); |
| }); |
|
|
| emitter.fire(1); |
| expect(seen).toEqual(['a']); |
| emitter.fire(2); |
| expect(seen).toEqual(['a', 'a', 'late']); |
| emitter.dispose(); |
| }); |
|
|
| it('listener removing itself during fire does not corrupt iteration', () => { |
| const emitter = new Emitter<number>(); |
| const seen: string[] = []; |
| const subA = emitter.event(() => { |
| seen.push('a'); |
| subA.dispose(); |
| }); |
| emitter.event(() => seen.push('b')); |
|
|
| emitter.fire(1); |
| emitter.fire(2); |
|
|
| expect(seen).toEqual(['a', 'b', 'b']); |
| emitter.dispose(); |
| }); |
| }); |
|
|
| describe('Event.None', () => { |
| it('returns Disposable.None and never fires', () => { |
| const seen: number[] = []; |
| const subscription = Event.None(() => seen.push(1)); |
|
|
| expect(subscription).toBe(Disposable.None); |
| expect(seen).toHaveLength(0); |
| }); |
| }); |
|
|
| describe('Emitter debug name / EventSubscription ledger labels', () => { |
| it('named emitter subscriptions land on the store ledger as on:<name>', () => { |
| const emitter = new Emitter<number>('test.event'); |
| const store = new DisposableStore(); |
|
|
| emitter.event(() => undefined, undefined, store); |
|
|
| expect(store.ledger.entries().map((entry) => entry.label)).toContain('on:test.event'); |
| store.dispose(); |
| emitter.dispose(); |
| }); |
|
|
| it('unnamed emitter subscriptions fall back to disposable:EventSubscription', () => { |
| const emitter = new Emitter<number>(); |
| const store = new DisposableStore(); |
|
|
| emitter.event(() => undefined, undefined, store); |
|
|
| expect(store.ledger.entries().map((entry) => entry.label)).toContain( |
| 'disposable:EventSubscription', |
| ); |
| store.dispose(); |
| emitter.dispose(); |
| }); |
|
|
| it('listenerCount tracks subscribe and dispose', () => { |
| const emitter = new Emitter<number>(); |
| expect(emitter.listenerCount).toBe(0); |
|
|
| const subscription = emitter.event(() => undefined); |
| expect(emitter.listenerCount).toBe(1); |
|
|
| subscription.dispose(); |
| expect(emitter.listenerCount).toBe(0); |
| emitter.dispose(); |
| }); |
| }); |
|
|
| describe('Event.once', () => { |
| it('delivers exactly once then auto-disposes', () => { |
| const emitter = new Emitter<number>(); |
| const seen: number[] = []; |
| Event.once(emitter.event)((value) => seen.push(value)); |
|
|
| emitter.fire(1); |
| emitter.fire(2); |
|
|
| expect(seen).toEqual([1]); |
| emitter.dispose(); |
| }); |
| }); |
|
|
| describe('Event.map', () => { |
| it('projects values', () => { |
| const emitter = new Emitter<number>(); |
| const doubled = Event.map(emitter.event, (value) => value * 2); |
| const seen: number[] = []; |
|
|
| doubled((value) => seen.push(value)); |
| emitter.fire(3); |
| emitter.fire(5); |
|
|
| expect(seen).toEqual([6, 10]); |
| emitter.dispose(); |
| }); |
| }); |
|
|
| describe('Event.filter', () => { |
| it('drops values that fail the predicate', () => { |
| const emitter = new Emitter<number>(); |
| const evens = Event.filter(emitter.event, (value) => value % 2 === 0); |
| const seen: number[] = []; |
|
|
| evens((value) => seen.push(value)); |
| emitter.fire(1); |
| emitter.fire(2); |
| emitter.fire(3); |
| emitter.fire(4); |
|
|
| expect(seen).toEqual([2, 4]); |
| emitter.dispose(); |
| }); |
| }); |
|
|
| describe('Event.any', () => { |
| it('forwards any source fire to the subscriber', () => { |
| const a = new Emitter<string>(); |
| const b = new Emitter<string>(); |
| const seen: string[] = []; |
| Event.any(a.event, b.event)((value) => seen.push(value)); |
|
|
| a.fire('A'); |
| b.fire('B'); |
| a.fire('A2'); |
|
|
| expect(seen).toEqual(['A', 'B', 'A2']); |
| a.dispose(); |
| b.dispose(); |
| }); |
|
|
| it('disposing the combined subscription detaches from all sources', () => { |
| const a = new Emitter<string>(); |
| const b = new Emitter<string>(); |
| const seen: string[] = []; |
| const subscription = Event.any(a.event, b.event)((value) => seen.push(value)); |
|
|
| a.fire('A'); |
| subscription.dispose(); |
| a.fire('A2'); |
| b.fire('B'); |
|
|
| expect(seen).toEqual(['A']); |
| a.dispose(); |
| b.dispose(); |
| }); |
|
|
| it('disposing the combined subscription disposes all source subscriptions before throwing AggregateError', () => { |
| const order: string[] = []; |
| const first: Event<string> = () => ({ |
| dispose: () => { |
| order.push('first'); |
| throw new Error('first-dispose'); |
| }, |
| }); |
| const second: Event<string> = () => ({ |
| dispose: () => { |
| order.push('second'); |
| throw new Error('second-dispose'); |
| }, |
| }); |
|
|
| const error = captureThrown(() => { |
| Event.any(first, second)(() => undefined).dispose(); |
| }); |
|
|
| expect(order).toEqual(['first', 'second']); |
| expect(error).toBeInstanceOf(AggregateError); |
| expect((error as AggregateError).errors.map((err) => (err as Error).message)).toEqual([ |
| 'first-dispose', |
| 'second-dispose', |
| ]); |
| }); |
| }); |
|
|
