🗒️ Jest 기본 문법 정리

우테코 6기 프리코스 2주차에 접어들면서
테스트 코드 작성을 위해 기본적인 Jest 문법을 정리해보았다.

0. Jest 설치 및 설정

0-1. 설치

npm init

npm install jest --save-dev

• 추천 : vscode 코드 자동 완성 기능 사용 가능

npm install jest @types/jest --save-dev

0-2. 설정

• package.json 수정해준다.

  "scripts": {
    "test": "jest"
  },

jest는 test 폴더 안에 넣은 파일들, .test.js ,.spec.js형식의 파일들을 자동으로 test 코드로 인식한다.

1. 테스트 기본 구조

1-1. 테스트 블록

• test 및 it: Jest에서는 test와 it이 동일한 기능을 수행한다. 두 함수 모두 단일 테스트 케이스를 정의한다.

  // test 함수 사용 예
  test('두 숫자의 합', () => {
    expect(1 + 2).toBe(3);
  });
  
  // it 함수 사용 예
  it('객체 할당 확인', () => {
    const obj = {};
    expect(obj).toEqual({});
  });

  
  

1-2. describe 블록

• 구조: describe 블록을 사용하여 관련 테스트 케이스를 그룹화한다. 이는 테스트가 어떤 모듈이나 기능에 관련되어 있는지 명확하게 표현하는 데 도움이 된다.

  // describe 블록 사용 예
  describe('String 관련 테스트', () => {
    test('문자열 합치기', () => {
      expect('Hello' + 'World').toBe('HelloWorld');
    });
  
    it('문자열 길이', () => {
      expect('Hello'.length).toEqual(5);
    });
  });

  
  

1-3. before와 after 훅

• 사용 목적: 공통된 준비 작업이나 정리 작업을 위해 사용된다.
  - beforeEach: 각 테스트가 실행되기 전에 실행된다.
  - afterEach: 각 테스트가 실행된 후에 실행된다.
  - beforeAll: 모든 테스트가 실행되기 전에 단 한 번만 실행된다.
  - afterAll: 모든 테스트가 실행된 후에 단 한 번만 실행된다.

  // before와 after 훅 사용 예
  describe('Array 관련 테스트', () => {
    let array;
  
    beforeEach(() => {
      array = [1, 2, 3];
    });
  
    afterEach(() => {
      array = [];
    });
  
    test('배열 요소 추가', () => {
      array.push(4);
      expect(array).toEqual([1, 2, 3, 4]);
    });
  
    it('배열 요소 제거', () => {
      array.pop();
      expect(array).not.toContain(3);
    });
  });

  
  

1-4. 테스트 필터링

• 특정 테스트 실행: test.only 또는 it.only를 사용하여, 특정 테스트 또는 테스트 그룹만 실행할 수 있다.

2. 단언 (Assertions)

2-1. 기본 단언

• toEqual vs toBe: toEqual은 객체의 내용이 같은지 확인하고, toBe는 같은 객체인지 (즉, 동일한 메모리 주소를 가리키는지) 확인한다.

  test('객체 내용 비교', () => {
    const obj = { a: 1, b: 2 };
    expect(obj).toEqual({ a: 1, b: 2 });
    expect(obj).not.toBe({ a: 1, b: 2 }); // toBe는 메모리 주소까지 비교하기 때문에 실패
  });
  

  
  

2-2. Truthiness

• toBeNull, toBeUndefined, toBeTruthy, toBeFalsy:

  test('null 검사', () => {
    const n = null;
    expect(n).toBeNull();
    expect(n).toBeDefined();
    expect(n).not.toBeUndefined();
    expect(n).not.toBeTruthy();
    expect(n).toBeFalsy();
  });

  
  

2-3. 숫자 관련 단언

• toBeGreaterThan, toBeLessThan: 숫자 비교를 위한 단언들이다.

  test('숫자 비교', () => {
    const value = 2 + 2;
    expect(value).toBeGreaterThan(3);
    expect(value).toBeLessThan(5);
    expect(value).toBe(4);
    expect(value).toEqual(4);
  });

  
  

• toBeCloseTo : 부동 소수점 숫자들을 비교한다.
  JavaScript의 부동 소수점 계산 오차 때문에 유용하다.
  예를 들어, 0.2 + 0.1이 정확히 0.3이 아닐 때, 이 단언은 두 숫자가 충분히 가까운지를 판단한다. 두 번째 인자로 소수점 아래 자릿수를 지정해 비교 정밀도를 조절한다.

    test("adding floats", () => {
      const value = 0.1 + 0.2;
      expect(value).toBeCloseTo(0.3);
      expect(value).toBeCloseTo(0.29); // fail
      expect(value).toBeCloseTo(0.299); // pass
    });

  
  

• toBeCloseTo : 두 번째 인자로 소수점 아래 자릿수를 지정할 수 있어, 비교의 정밀도를 조절할 수 있다.
  예를 들어, 두 숫자가 소수점 아래 두 자리까지만 비교하려면 다음과 같이 사용한다.

  expect(0.223).toBeCloseTo(0.22, 2); // pass

  
  

2-4. 문자열 관련 단언

• toMatch: 정규식을 사용해 문자열을 테스트할 수 있다.

  test('문자열에 특정 문자가 있는지 확인', () => {
    expect('team').not.toMatch(/I/);
    expect('Christoph').toMatch(/stop/);
  });

  
  

2-5. 배열과 반복 가능 객체

• toContain: 배열이나 반복 가능 객체가 특정 항목을 포함하는지 확인한다.

  test('배열에 특정 요소가 있는지 확인', () => {
    const shoppingList = ['diapers', 'kleenex', 'trash bags', 'paper towels', 'milk'];
    expect(shoppingList).toContain('milk');
    expect(new Set(shoppingList)).toContain('milk');
  });

  
  

• toContainEqual : 배열이 특정 요소를 포함하고 있는지 확인한다. 요소가 객체인 경우에도 정확한 일치 여부를 검사한다.

  // 배열 안에 { name: "Bob" } 객체가 포함되어 있는지를 확인
  expect([{ name: "Alice" }, { name: "Bob" }]).toContainEqual({ name: "Bob" });

  
  

2-6. 예외

• toThrow: 함수가 특정 예외를 던지는지 테스트한다.

  function compileAndroidCode() {
    throw new Error('you are using the wrong JDK');
  }
  
  test('특정 오류를 던지는지 확인', () => {
    expect(() => compileAndroidCode()).toThrow();
    expect(() => compileAndroidCode()).toThrow(Error);
  
    // 오류 메시지나 정규식을 이용한 오류 검사
    expect(() => compileAndroidCode()).toThrow('you are using the wrong JDK');
    expect(() => compileAndroidCode()).toThrow(/JDK/);
  });

  
  

3. 모의 함수 (Mock Functions)

3-1. 모의 함수 생성

• jest.fn(): 모의 함수를 생성하고, 호출 정보를 추적한다.

  test('모의 함수 예제', () => {
    const mockFn = jest.fn();
    mockFn(1);
    expect(mockFn).toHaveBeenCalled();
    expect(mockFn).toHaveBeenCalledWith(1);
  });

  
  

3-2. 모의 함수 사용

• 함수 모의 : 외부 함수 호출의 영향을 줄이기 위해, 실제 함수 대신 모의 함수를 사용한다.

  test('모의 구현 예제', () => {
    const mockFn = jest.fn().mockImplementation(scalar => 42 + scalar);
    // 또는 jest.fn(scalar => 42 + scalar);
  
    expect(mockFn(1)).toBe(43);
  });
  

  
  

• 모의 구현 : mockImplementation()을 사용하여 모의 함수의 구체적인 동작을 정의할 수 있다.

  test('모의 구현 예제', () => {
    const mockFn = jest.fn().mockImplementation(scalar => 42 + scalar);
    // 또는 jest.fn(scalar => 42 + scalar);
  
    expect(mockFn(1)).toBe(43);
  });
  

  
  

3-3. 모의 함수 검증

• toHaveBeenCalled, toHaveBeenCalledTimes : 함수가 호출되었는지, 특정 횟수만큼 호출되었는지 확인한다.

  test('모의 함수 호출 여부 및 횟수 검증', () => {
    const mockFn = jest.fn();
    mockFn();
    mockFn([1, 2, 3]);
  
    // 함수가 호출되었는지
    expect(mockFn).toHaveBeenCalled();
  
    // 정확히 2번 호출되었는지
    expect(mockFn).toHaveBeenCalledTimes(2);
  
    // 두 번째 호출 때 첫 번째 인자가 [1, 2, 3]이었는지
    expect(mockFn.mock.calls[1][0]).toEqual([1, 2, 3]);
  });

  
  
  

4. 비동기 테스트

4-1. Promise 테스트

• resolves, rejects: Promise가 해결되거나 거부될 때의 상태를 테스트한다.

  test('Promise가 성공적으로 해결되는지 확인', () => {
    return expect(Promise.resolve('성공')).resolves.toBe('성공');
  });
  
  test('Promise가 실패하며 오류를 던지는지 확인', () => {
    return expect(Promise.reject(new Error('실패'))).rejects.toThrow('실패');
  });
  

  
  

4-2. async/await 사용

• 비동기 함수: async 함수 내에서 await expect()을 사용하여 비동기 함수를 테스트한다.

  test('async/await을 사용한 비동기 테스트', async () => {
    await expect(Promise.resolve('성공')).resolves.toBe('성공');
    await expect(Promise.reject(new Error('실패'))).rejects.toThrow('실패');
  });
  

  
  

---

📓 정보 출처

• Jest docs