jest-mock-extended - GitLite

KO | EN

gitlite — search

#react #ai #typescript #go #macos #windows #awesome #kubernetes #awesome-list #pytorch #security #ios #mcp #openai

jest-mock-extended

(★ 906)

Type safe mocking extensions for Jest https://www.npmjs.com/package/jest-mock-extended

파일 탐색기

최종 버전 다운로드 (.zip)

- CalledWithFn.ts
- index.ts
- Matchers.spec.ts
- Matchers.ts
- Mock.spec.ts
- Mock.ts
.gitignore
.prettierrc
.travis.yml
jest.config.js
LICENSE
package.json
README.md
tsconfig.json

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/marchaos/jest-mock-extended

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd jest-mock-extended

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Node.js

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Node.js npm 명령어를 쓰려면 Node.js가 설치되어 있어야 합니다. LTS(장기지원) 버전을 추천합니다.

npm install jest-mock-extended --save-dev

package.json에 명시된 라이브러리들을 내려받아 설치합니다.

yarn add jest-mock-extended --dev

이 명령어를 터미널에 그대로 입력해 실행하세요.

✅ 명령어 실행 후 터미널에 나타나는 주소(보통 http://localhost:3000 형태)를 브라우저에서 열어보세요.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# jest-mock-extended
> Type safe mocking extensions for Jest 🃏

[![Build Status](https://travis-ci.com/marchaos/jest-mock-extended.svg?branch=master)](https://travis-ci.com/marchaos/jest-mock-extended)
[![Coverage Status](https://coveralls.io/repos/github/marchaos/jest-mock-extended/badge.svg?branch=master)](https://coveralls.io/github/marchaos/jest-mock-extended?branch=master)
[![npm version](https://badge.fury.io/js/jest-mock-extended.svg)](https://badge.fury.io/js/jest-mock-extended)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![npm downloads](https://badgen.net/npm/dw/jest-mock-extended)](https://badge.fury.io/js/jest-mock-extended)

## Features
- Provides complete Typescript type safety for interfaces, argument types and return types
- Ability to mock any interface or object
- calledWith() extension to provide argument specific expectations, which works for objects and functions.
- Extensive Matcher API compatible with Jasmine matchers
- Supports mocking deep objects / class instances.
- Familiar Jest like API

## Installation
```bash
npm install jest-mock-extended --save-dev
```
or
```bash
yarn add jest-mock-extended --dev
```

## Example

```ts
import { mock } from 'jest-mock-extended';

interface PartyProvider {
   getPartyType: () => string;
   getSongs: (type: string) => string[]
   start: (type: string) => void;
}

describe('Party Tests', () => {
   test('Mock out an interface', () => {
       const mock = mock<PartyProvider>();
       mock.start('disco party');
       
       expect(mock.start).toHaveBeenCalledWith('disco party');
   });
   
   
   test('mock out a return type', () => {
       const mock = mock<PartyProvider>();
       mock.getPartyType.mockReturnValue('west coast party');
       
       expect(mock.getPartyType()).toBe('west coast party');
   });

test('throwing an error if we forget to specify the return value')
        const mock = mock<PartyProvider>(
            {},
            {
                fallbackMockImplementation: () => {
                    throw new Error('not mocked');
                },
            }
        );

expect(() => mock.getPartyType()).toThrowError('not mocked');
    });
```

## Assigning Mocks with a Type

If you wish to assign a mock to a variable that requires a type in your test, then you should use the MockProxy<> type
given that this will provide the apis for calledWith() and other built-in jest types for providing test functionality.

```ts
import { MockProxy, mock } from 'jest-mock-extended';

describe('test', () => {
    let myMock: MockProxy<MyInterface>;

beforeEach(() => {
        myMock = mock<MyInterface>();
    })

test(() => {
         myMock.calledWith(1).mockReturnValue(2);
         ...
    })
});

```

## calledWith() Extension

```jest-mock-extended``` allows for invocation matching expectations. Types of arguments, even when using matchers are type checked.

```ts
const provider = mock<PartyProvider>();
provider.getSongs.calledWith('disco party').mockReturnValue(['Dance the night away', 'Stayin Alive']);
expect(provider.getSongs('disco party')).toEqual(['Dance the night away', 'Stayin Alive']);

// Matchers
provider.getSongs.calledWith(any()).mockReturnValue(['Saw her standing there']);
provider.getSongs.calledWith(anyString()).mockReturnValue(['Saw her standing there']);

```
You can also use ```mockFn()``` to create a ```jest.fn()``` with the calledWith extension:

```ts
 type MyFn = (x: number, y: number) => Promise<string>;
 const fn = mockFn<MyFn>();
 fn.calledWith(1, 2).mockReturnValue('str');
```

## Clearing / Resetting Mocks

```jest-mock-extended``` exposes a mockClear and mockReset for resetting or clearing mocks with the same 
functionality as ```jest.fn()```.

```ts
import { mock, mockClear, mockReset } from 'jest-mock-extended';

describe('test', () => {
   const mock: UserService = mock<UserService>();
   
   beforeEach(() => {
      mockReset(mock); // or mockClear(mock)
   });
   ...
})
```

## Deep mocks

If your class has objects returns from methods that you would also like to mock, you can use ```mockDeep``` in 
replacement for mock.

```ts
import { mockDeep } from 'jest-mock-extended';

const mockObj: DeepMockProxy<Test1> = mockDeep<Test1>();
mockObj.deepProp.getNumber.calledWith(1).mockReturnValue(4);
expect(mockObj.deepProp.getNumber(1)).toBe(4);
```
if you also need support for properties on functions, you can pass in an option to enable this

```ts
import { mockDeep } from 'jest-mock-extended';

const mockObj: DeepMockProxy<Test1> = mockDeep<Test1>({ funcPropSupport: true });
mockObj.deepProp.calledWith(1).mockReturnValue(3)
mockObj.deepProp.getNumber.calledWith(1).mockReturnValue(4);

expect(mockObj.deepProp(1)).toBe(3);
expect(mockObj.deepProp.getNumber(1)).toBe(4);
```

Can can provide a fallback mock implementation used if you do not define a return value using `calledWith`.

```ts
import { mockDeep } from 'jest-mock-extended';
const mockObj = mockDeep<Test1>({
    fallbackMockImplementation: () => {
        throw new Error('please add expected return value using calledWith');
    },
});
expect(() => mockObj.getNumber()).toThrowError('not mocked');
```

## Available Matchers

| Matcher               | Description                                                           |
|-----------------------|-----------------------------------------------------------------------|
|any()                  | Matches any arg of any type.                                          |
|anyBoolean()           | Matches any boolean (true or false)                                   |
|anyString()            | Matches any string including empty string                             |
|anyNumber()            | Matches any number that is not NaN                                    |
|anyFunction()          | Matches any function                                                  |
|anyObject()            | Matches any object (typeof m === 'object') and is not null            |
|anyArray()             | Matches any array                                                     |
|anyMap()               | Matches any Map                                                       |
|anySet()               | Matches any Set                                                       |
|isA(class)             | e.g isA(DiscoPartyProvider)                                           |
|includes('value')      | Checks if value is in the argument array                              |
|containsKey('key')     |  Checks if the key exists in the object                               |
|containsValue('value') | Checks if the value exists in an object                               |
|has('value')           | checks if the value exists in a Set                                   |
|notNull()              | value !== null                                                        |
|notUndefined()         | value !== undefined                                                   |
|notEmpty()             | value !== undefined && value !== null && value !== ''                 |
|captor()               | Used to capture an arg - alternative to mock.calls[0][0]              |

## Writing a Custom Matcher

Custom matchers can be written using a ```MatcherCreator```

```ts
import { MatcherCreator, Matcher } from 'jest-mock-extended';

// expectedValue is optional
export const myMatcher: MatcherCreator<MyType> = (expectedValue) => new Matcher((actualValue) => {
    return (expectedValue === actualValue && actualValue.isSpecial);
});
```

By default, the expected value and actual value are the same type. In the case where you need to type the expected value 
differently than the actual value, you can use the optional 2 generic parameter:

```ts
import { MatcherCreator, Matcher } from 'jest-mock-extended';

// expectedValue is optional
export const myMatcher: MatcherCreator<string[], string> = (expectedValue) => new Matcher((actualValue) => {
    return (actualValue.includes(expectedValue));
});
```