How do you ensure proper cleanup when mocking async functions in Mocha

1. Use a Sandbox: Create a Sinon.js sandbox in the `beforeEach` hook and restore it in the `afterEach` hook. This allows you to manage all the mocks and stubs created during the test within the sandbox.

typescript
import * as sinon from 'sinon';
import { expect } from 'chai';
import { myAsyncFunction } from './myModule';

describe('myAsyncFunction', () => {
  let sandbox: sinon.SinonSandbox;

  beforeEach(() => {
    sandbox = sinon.createSandbox();
  });

  afterEach(() => {
    sandbox.restore();
  });

  it('should return the expected value', async () => {
    // Create a stub for the asynchronous function
    const stub = sandbox.stub(this, 'myAsyncFunction').resolves('mocked value');

    const result = await myAsyncFunction();
    expect(result).to.equal('mocked value');
    expect(stub).to.have.been.called;
  });
});

2. Clear Mocks After Each Test: If you're not using a sandbox, make sure to clear the mocks after each test using `sinon.resetHistory()` or `sinon.restore()`.

typescript
import * as sinon from 'sinon';
import { expect } from 'chai';
import { myAsyncFunction } from './myModule';

describe('myAsyncFunction', () => {
  afterEach(() => {
    sinon.resetHistory();
  });

  it('should return the expected value', async () => {
    const stub = sinon.stub(this, 'myAsyncFunction').resolves('mocked value');

    const result = await myAsyncFunction();
    expect(result).to.equal('mocked value');
    expect(stub).to.have.been.called;
  });
});

3. Use a Cleanup Function: If you have a more complex setup or teardown process, you can create a dedicated cleanup function and call it in the `afterEach` hook.

typescript
import * as sinon from 'sinon';
import { expect } from 'chai';
import { myAsyncFunction, myOtherAsyncFunction } from './myModule';

describe('myAsyncFunction', () => {
  let sandbox: sinon.SinonSandbox;

  beforeEach(() => {
    sandbox = sinon.createSandbox();
  });

  afterEach(() => {
    cleanupMocks();
  });

  function cleanupMocks() {
    sandbox.restore();
    sinon.resetHistory();
    // Add any other cleanup logic here
  }

  it('should return the expected value', async () => {
    const stub = sandbox.stub(this, 'myAsyncFunction').resolves('mocked value');
    const otherStub = sandbox.stub(this, 'myOtherAsyncFunction').resolves('other mocked value');

    const result = await myAsyncFunction();
    expect(result).to.equal('mocked value');
    expect(stub).to.have.been.called;
    expect(otherStub).to.have.been.called;
  });
});

By following these steps, you can ensure that your mocks are properly cleaned up after each test, preventing any unintended side effects or leaks between tests. This helps maintain a clean and reliable test environment, making it easier to debug issues and ensure the correctness of your asynchronous function tests.