disposable.test.ts

/**

 * @license

 * Copyright 2025 Google Inc.

 * SPDX-License-Identifier: Apache-2.0

*/

import {describe, it, beforeEach} from 'node:test';

import expect from 'expect';

import sinon from 'sinon';

import {

  DisposableStack,

  disposeSymbol,

  AsyncDisposableStack,

  asyncDisposeSymbol,

  SuppressedError,

} from './disposable.js';

describe('DisposableStack', () => {

  let stack: DisposableStack;

  beforeEach(() => {

    stack = new DisposableStack();

});

  it('should dispose resources in LIFO order', () => {

    const dispose1 = sinon.spy();

    const dispose2 = sinon.spy();

    stack.adopt({}, dispose1);

    stack.adopt({}, dispose2);

    stack.dispose();

    expect(dispose2.calledBefore(dispose1)).toBeTruthy();

});

  it('should not dispose resources if already disposed', () => {

    const dispose = sinon.spy();

    stack.adopt({}, dispose);

    stack.dispose();

    stack.dispose();

    expect(dispose.calledOnce).toBeTruthy();

});

  it('should use disposable resources', () => {

    const resource = {

      [disposeSymbol]: sinon.spy(),

};

    stack.use(resource);

    stack.dispose();

    expect(resource[disposeSymbol].calledOnce).toBeTruthy();

});

  it('should defer disposal callbacks', () => {

    const onDispose = sinon.spy();

    stack.defer(onDispose);

    stack.dispose();

    expect(onDispose.calledOnce).toBeTruthy();

});

  it('should move resources to a new stack', () => {

    const dispose = sinon.spy();

    stack.adopt({}, dispose);

    const newStack = stack.move();

    expect(stack.disposed).toBeTruthy();

    expect(newStack.disposed).toBeFalsy();

    newStack.dispose();

    expect(dispose.calledOnce).toBeTruthy();

});

  it('should throw error if moving a disposed stack', () => {

    stack.dispose();

    expect(() => {

      return stack.move();

    }).toThrow(ReferenceError);

});

  it('should collect errors from disposals', async () => {

    const error1 = new Error('dispose1');

    const error2 = new Error('dispose2');

    const error3 = new Error('dispose3');

    const dispose1 = sinon.stub().throws(error1);

    const dispose2 = sinon.stub().throws(error2);

    const dispose3 = sinon.stub().throws(error3);

    stack.adopt({}, dispose1);

    stack.adopt({}, dispose2);

    stack.adopt({}, dispose3);

    let error!: SuppressedError;

    try {

      stack.dispose();

    } catch (e) {

      error = e as SuppressedError;

    expect(error instanceof SuppressedError).toBeTruthy();

    expect(error.name).toEqual('SuppressedError');

    expect(error.message).toEqual('An error was suppressed during disposal');

    expect(error.error).toEqual(error1);

    expect(error.suppressed.error).toEqual(error2);

    expect(error.suppressed.suppressed).toEqual(error3);

});

});

describe('AsyncDisposableStack', () => {

  let stack: AsyncDisposableStack;

  beforeEach(() => {

    stack = new AsyncDisposableStack();

});

  it('should dispose resources in LIFO order', async () => {

    const dispose1 = sinon.stub().resolves();

    const dispose2 = sinon.stub().resolves();

    stack.adopt({}, dispose1);

    stack.adopt({}, dispose2);

    await stack.disposeAsync();

    expect(dispose2.calledBefore(dispose1)).toBeTruthy();

});

  it('should not dispose resources if already disposed', async () => {

    const dispose = sinon.stub().resolves();

    stack.adopt({}, dispose);

    await stack.disposeAsync();

    await stack.disposeAsync();

    expect(dispose.calledOnce).toBeTruthy();

});

  it('should use async disposable resources', async () => {

    const resource = {

      [asyncDisposeSymbol]: sinon.stub().resolves(),

};

    stack.use(resource);

    await stack.disposeAsync();

    expect(resource[asyncDisposeSymbol].calledOnce).toBeTruthy();

});

  it('should defer async disposal callbacks', async () => {

    const onDispose = sinon.stub().resolves();

    stack.defer(onDispose);

    await stack.disposeAsync();

    expect(onDispose.calledOnce).toBeTruthy();

});

  it('should move resources to a new stack', async () => {

    const dispose = sinon.stub().resolves();

    stack.adopt({}, dispose);

    const newStack = stack.move();

    expect(stack.disposed).toBeTruthy();

    expect(newStack.disposed).toBeFalsy();

    await newStack.disposeAsync();

    expect(dispose.calledOnce).toBeTruthy();

});

  it('should throw error if moving a disposed stack', () => {

    stack.disposeAsync();

    expect(() => {

      return stack.move();

    }).toThrow(ReferenceError);

});

  it('should collect errors from async disposals', async () => {

    const error1 = new Error('dispose1');

    const error2 = new Error('dispose2');

    const error3 = new Error('dispose3');

    const dispose1 = sinon.stub().rejects(error1);

    const dispose2 = sinon.stub().rejects(error2);

    const dispose3 = sinon.stub().rejects(error3);

    stack.adopt({}, dispose1);

    stack.adopt({}, dispose2);

    stack.adopt({}, dispose3);

    let error!: SuppressedError;

    try {

      await stack.disposeAsync();

    } catch (e) {

      error = e as SuppressedError;

    expect(error instanceof SuppressedError).toBeTruthy();

    expect(error.name).toEqual('SuppressedError');

    expect(error.message).toEqual('An error was suppressed during disposal');

    expect(error.error).toEqual(error1);

    expect(error.suppressed.error).toEqual(error2);

    expect(error.suppressed.suppressed).toEqual(error3);

});

});