[jest]

🍉 jest 시작하기

npm init --yes
npm i jest --global
jest --init
npm i --save-dev jest
npm i @types/jest

jest --coverage : 커버리지 확인

변경할 때마다 모든 test 실행

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

commit되지 않은 파일만 test 실행

git init
.gitignore에 'node_modules/*' 추가 
git add .
git commit

  "scripts": {
    "test": "jest --watch" // 
  },    

---

🍉 기본 테스트 작성

• 예제) calculator.js

class Calculator {
  constructor() {
    this.value = 0;
  }

  set(num) {
    this.value = num;
  }

  clear() {
    this.value = 0;
  }

  add(num) {
    const sum = this.value + num;
    if (sum > 100) {
      throw new Error('Value can not be greater than 100');
    }
    this.value = sum;
  }

  subtract(num) {
    this.value = this.value - num;
  }

  multiply(num) {
    this.value = this.value * num;
  }

  divide(num) {
    this.value = this.value / num;
  }
}

module.exports = Calculator;

• describe : 관련있는 테스트끼리 묶음.
• beforeEach : 각각의 테스트가 실해오디기 전에 실행
  (각각의 테스트는 독립적으로 실행되어야 한다. 즉, 이전의 테스트 결과가 이후의 테스트에 영향을 미치면 안된다.)
  beforeEach, afterEach, beforeAll, afterAll => jest 공식

describe('Calculator', () => {
  let cal;
  // 각각의 테스트가 실행되기 전에 새로운 object를 생성
  beforeEach(() => {
    cal = new Calculator();
  });

  it('inits with 0', () => {
    expect(cal.value).toBe(0);
  });
  
  it('subtract', () => {
    cal.set(1);
    cal.subtract(2);
    expect(cal.value).toBe(-1);
  });

   describe('divides', () => {
    it('0 divide 0', () => {
      cal.divide(0);
      expect(cal.value).toBe(NaN);
    });

    it('1 divide 0', () => {
      cal.set(1);
      cal.divide(0);
      expect(cal.value).toBe(Infinity);
    });
  });
});

---

🍉 에러 테스트

• expect().toThrow() : 에러 테스트

 it('add should throw an error if value is greater than 100', () => {
    expect(() => {
      cal.add(101);
    }).toThrow('Value can not be greater than 100');
  });

---

🍉 비동기 테스트

const fetchProduct = require('../async.js');

describe('Asnyc', () => {
  /* done 방식 */
  it('aysnc-done', (done) => {
    fetchProduct().then((item) => {
      expect(item).toEqual({ item: 'Mike', price: 200 });
      done(); //=> jest가 끝나는 시점 지정 (5초 정도 기다리기 때문에 테스트 수행이 느림)
    });
  });
  
  /* async return 방식 */
  it('aysnc-return', () => {
    return fetchProduct().then((item) => {
      expect(item).toEqual({ item: 'Mike', price: 200 });
    });
  });

  it('aysnc-return-error', () => {
    return fetchProduct().catch((item) => {
      expect(item).toEqual('network error');
    });
  });

  /* async await 방식 */
  it('aysnc-await', async () => {
    const product = await fetchProduct();
    expect(product).toEqual({ item: 'Mike', price: 200 });
  });

  it('aysnc-await-error', async () => {
    try {
      await fetchProduct('error');
    } catch (error) {
      expect(error).toBe('network error');
    }
  });

  /* async resolves, rejects 방식 */
  it('aysnc-resolves', () => {
    return expect(fetchProduct()).resolves.toEqual({
      item: 'Mike',
      price: 200,
    });
  });

  it('aysnc-rejects', () => {
    return expect(fetchProduct('error')).rejects.toBe('network error');
  });
});

---

🍉 Mock 함수

mock 함수를 통해 실제 함수를 구현하지 않고, 간단하게 test 진행 가능하다.

• check.js

function check(predicate, onSuccess, onFail) {
  if (predicate()) {
    onSuccess('yes');
  } else {
    onFail('no');
  }
}

module.exports = check;

• check.test.js

const check = require('../check.js');

describe('check', () => {
  let onSuccess;
  let onFail;

  beforeEach(() => {
    onSuccess = jest.fn(); //-> 가짜 함수 생성
    onFail = jest.fn(); //-> 가짜 함수 생성
  });

  it('should call onSuccess when predicate is true', () => {
    check(() => true, onSuccess, onFail);

    // expect(onSuccess.mock.calls.length).toBe(1);
    // expect(onSuccess.mock.calls[0][0]).toBe(1);
    // expect(onFail.mock.calls.length).toBe(0);

    expect(onSuccess).toHaveBeenCalledTimes(1);
    expect(onSuccess).toHaveBeenCalledWith('yes');
    expect(onFail).toHaveBeenCalledTimes(0);
  });

  it('should call onFail when predicate is false', () => {
    check(() => false, onSuccess, onFail);
    expect(onFail).toHaveBeenCalledTimes(1);
    expect(onFail).toHaveBeenCalledWith('no');
    expect(onSuccess).toHaveBeenCalledTimes(0);
  });
});

---

🍉 제품 정보 가져오기

• product_client.js

class ProductClient {
  fetchItems() {
    return fetch('http://example.com/login/id+password').then((res) =>
      res.json()
    );
  }
}

module.exports = ProductClient;

• product_service_no_di.js

const ProductClient = require('./product_client');

class ProductService {
  constructor() {
    this.ProductClient = new ProductClient();
  }

  fetchAvailableItems() {
    return this.ProductClient.fetchItems().then((items) =>
      items.filter((item) => item.available)
    );
  }
}

module.exports = ProductService;

⚠️ mock 이용 (mock 남용)

• 여기서 테스트하고자 하는 것은 product_service_no_di이기 때문에, 다른 어떤 의존성에 대해서는 mock을 이용한다.
• 다른 단위 간의 의존성이 존재하면 mock을 이용하여 의존성을 제거할 수 있다.

const ProductService = require('../product_service_no_di.js');
const ProductClient = require('../product_client.js');

// product_client은 mock으로 사용한다고 명시
jest.mock('../product_client');

describe('product service', () => {
  // fetchItems에 대해서 mock 함수 생성
  const fetchItems = jest.fn(async () => [
    { item: '🥛', available: true },
    { item: '🍌', available: false },
  ]);

  //product_client와 fetchItems 함수 연결
  ProductClient.mockImplementation(() => {
    return {
      fetchItems,
    };
  });

  let productService;

  beforeEach(() => {
    productService = new ProductService();
    //=> network 상태에 의존하는 코드는 좋지 않다.
    // 의존성을 제거하기 위해 product_client을 mock한다.
  });

  it('should filter out only available items', async () => {
    const items = await productService.fetchAvailableItems();
    expect(items.length).toBe(1);
    expect(items).toEqual([{ item: '🥛', available: true }]);
  });
});

⚠️ stub 이용

---