AutoMock

Standalone Library for Dependencies Auto Mocking (for TypeScript)

Works with any testing framework!

Create unit test simply and easily with 100% isolation of class dependencies

Installation

💡 Install jest-mock-extended as a peer dependency

With NPM:

npm i -D jest-unit jest-mock-extended

Or with Yarn:

yarn add -D jest-unit jest-mock-extended

Who can use this library? 🤩

TL;DR

If you are using this pattern in your framework (it doesn't matter which one):

export class AwesomeClass {
  public constructor(private readonly dependecy1: SomeOtherClass) {}
}

You can use Jest Unit :)

Tell me more 🤔

If you are using any TypeScript framework: Angular, React+TypeScript, NestJS, TypeDI, TsED or even if you are framework free, jest unit is for you.

Jest Unit is framework agnostic, so it's basically serves everyone! if you are using any implementation of dependency inversion (dependency injection on most cases) this library is for you.

The only assumption/requirement is that you are taking your class dependencies via the class constructor (like in the example above).

What is this library❓

This package helps isolate the dependencies of any given class, by using a simple reflection mechanism on the class constructor params metadata. When used in conjunction with jest-mock-extended library, all the class dependencies (constructor params) will be overridden automatically and become mocks (or deep mocks if you want it to).

Example and Usage 💁‍

import { DeepMockOf, MockOf, Spec } from 'jest-unit';

describe('SomeService Unit Test', () => {
  let someService: SomeService;
  let logger: MockOf<Logger>;
  let userService: MockOf<UserService>;

  const USERS_DATA = [{ name: 'user', email: '[email protected]' }];

  beforeAll(() => {
    const { unit, unitRef } = Spec.createUnit<SomeService>(SomeService)
      .mock(FeatureFlagService)
      .using({
        isFeatureOn: () => Promise.resolve(true),
      })
      // All the rest of the dependencies will be mocked
      // Pass true if you want to deep mock all of the rest
      .compile();

    someService = unit;
    userService = unitRef.get(UserService);
  });

  describe('When something happens', () => {
    beforeAll(() => (userService.getUsers.mockResolvedValueOnce(USERS_DATA));
    
    test('then check something', async () => {
      const result = await service.doSomethingNice();

      expect(logger.log).toHaveBeenCalledWith(USERS_DATA);
      expect(result).toEqual(USERS_DATA);
    });
  });
});

@Reflectable()
export class SomeService {
  public constructor(
    private readonly logger: Logger,
    private readonly catsService: CatsService,
    private readonly userService: UserService,
    private readonly featureFlagService: FeatureFlagService,
  ) {}
  
  public async doSomethingNice() {
    if (this.featureFlagService.isFeatureOn()) {
      const users = await this.userService.getUsers('https://example.com/json.json');
      this.logger.log(users);

      return users;
    }
    
    return null;
  }
}

Still need further example? Jump to full sample 📄

Motivation 💪

Unit tests exercise very small parts of the application in complete isolation.
"Complete isolation" means that, when unit testing, you don’t typically connect your application with external dependencies such as databases, the filesystem, or HTTP services. That allows unit tests to be fast and more stable since they won’t fail due to problems with those external services. (Thank you, Testim.io - jump to source)

More about jest-mock-extended package 📦

jest-mock-extended is a library which enables type safe mocking for Jest with TypeScript. It provides a complete Typescript type safety for interfaces, argument types and return types and has the ability to mock any interface or object.

License 📜

Distributed under the MIT License. See LICENSE for more information.

Acknowledgements 📙

jest-mock-extended