How do you handle mocking internal functions within a dependency class in TypeScript

1. Use `jest.mock` to mock the dependency class:

typescript
jest.mock('./dependency-class', () => {
  const originalModule = jest.requireActual('./dependency-class');

  return {
    ...originalModule,
    internalFunction: jest.fn(),
  };
});

This mocks the entire `DependencyClass` and replaces the `internalFunction` with a mock implementation.

2. Get a reference to the mocked function:

typescript
import { DependencyClass } from './dependency-class';

const mockedInternalFunction = DependencyClass.internalFunction as jest.Mock;

By casting the mocked function to `jest.Mock`, you can use Jest's mock function methods like `mockReturnValueOnce`.

3. Set expectations on the mocked function:

typescript
beforeEach(() => {
  mockedInternalFunction.mockClear();
  mockedInternalFunction.mockReturnValueOnce('mocked result');
});

it('should call the internal function', () => {
  const result = classUnderTest.methodCallingInternalFunction();
  expect(result).toBe('mocked result');
  expect(mockedInternalFunction).toHaveBeenCalled();
});

In the `beforeEach` block, clear the mock and set the expected return value. Then, in the test, assert that the mocked function is called with the expected arguments and that the class under test receives the mocked result.

By following these steps, you can effectively mock internal functions within a dependency class in TypeScript using Jest:

1. Mock the entire dependency class using `jest.mock`.
2. Get a reference to the mocked internal function and cast it to `jest.Mock`.
3. Set expectations on the mocked function using Jest's mock function methods.

This approach allows you to test the behavior of the class under test without relying on the actual implementation of the dependency class's internal functions.