해당 포스트는 도서 이펙티브 소프트웨어 테스팅(Effective Software Testing)을 Typescript와 Jest 테스팅 프레임워크를 기준으로 해석한 내용입니다. 코드 변환간 불일치가 존재할 수 있습니다.

테스트를 하는 개발자와 하지 않는 개발자

• 입력: Estimate 목록. 각 항목은 개발자의 이름과 추정값을 포합한다.
• 출력: String 목록. 가장 낮은 추정값과 높은 추정값을 제시한 개발자의 이름을 포함한다.

1class Estimate {
2  public constructor(
3    public developer: string,
4    public estimate: number,
5  ) {
6    this.developer = developer;
7    this.estimate = estimate;
8  }
9}
10
11export class PlanningPoker {
12  public identifyExtremes(estimates: Estimate[]): string[] {
13    let lowestEstimate: Estimate | null = null;
14    let highestEstimate: Estimate | null = null;
15
16    for (const estimate of estimates) {
17      if (!highestEstimate || estimate.estimate > highestEstimate.estimate) {
18        highestEstimate = estimate;
19      } else if (!lowestEstimate || estimate.estimate < lowestEstimate.estimate) {
20        lowestEstimate = estimate;
21      }
22    }
23
24    return [lowestEstimate!.developer, highestEstimate!.developer];
25  }
26}
27

1. 가장 낮은 예측치와 높은 예측치를 저장할 변수를 선언한다.
2. 현재 예측치가 지금까지 가장 높은 예측치라면 highestEstimate를 교체한다.
3. 현재 예측치가 지금까지 가장 낮은 예측치라면 lowestEstimate를 교체한다.
4. 양극단의 예측치를 제시한 개발자를 반환한다.

테스트를 하지 않는 경우

1테드: 16
2바니: 8
3릴리: 2
4로빈: 4
5
6result: "릴리"와 "테드"가 이유를 설명합니다.
7

1테드: 2
2바니: 4
3릴리: 8
4로빈: 16
5
6result: ERROR!!
7

1for (const estimate of estimates) {
2  if (!highestEstimate || estimate.estimate > highestEstimate.estimate) {
3    highestEstimate = estimate;
4  }
5  if (!lowestEstimate || estimate.estimate < lowestEstimate.estimate) {
6    lowestEstimate = estimate;
7  }
8}
9

테스트 코드가 없을 경우의 문제점

테스트를 진행하는 경우

1export class IllegalArgumentException extends Error {}
2
3// ...
4if (!estimates) {
5  throw new IllegalArgumentException("Estimates can't be null");
6}
7if (estimates.length <= 1) {
8  throw new IllegalArgumentException('There has to be more than 1 estimate in the list');
9}
10

1it('null 입력을 거부한다.', () => {
2  expect(() => planningPoker.identifyExtremes(null)).toThrow(IllegalArgumentException);
3});
4
5it('빈 입력을 거부한다.', () => {
6  const emptyList: Estimate[] = [];
7  expect(() => planningPoker.identifyExtremes(emptyList)).toThrow(IllegalArgumentException);
8});
9
10it('요소가 하나인 입력을 거부한다.', () => {
11  const list: Estimate[] = [new Estimate('Eleanor', 1)];
12  expect(() => planningPoker.identifyExtremes(list)).toThrow(IllegalArgumentException);
13});
14

1it('두개의 추정', () => {
2  const list: Estimate[] = [new Estimate('Mauricio', 10), new Estimate('Frank', 5)];
3
4  const devs: string[] = planningPoker.identifyExtremes(list);
5
6  expect(devs).toEqual(expect.arrayContaining(['Mauricio', 'Frank']));
7});
8
9it('여러개의 추정', () => {
10  const list: Estimate[] = [
11    new Estimate('Mauricio', 10),
12    new Estimate('Arie', 5),
13    new Estimate('Frank', 7),
14  ];
15
16  const devs: string[] = planningPoker.identifyExtremes(list);
17
18  expect(devs).toEqual(expect.arrayContaining(['Mauricio', 'Arie']));
19});
20

1it('랜덤 추정', () => {
2  function shuffle(array: unknown[]) {
3    array.sort(() => Math.random() - 0.5);
4  }
5
6  function generateEstimate() {
7    const alphabet = 'abcdefghijklmnopqrstuvwxyz';
8    let name = '';
9    for (let i = 0; i < 5; i++) {
10      const randomIndex = Math.floor(Math.random() * alphabet.length);
11      name += alphabet[randomIndex];
12    }
13
14    const value = Math.floor(Math.random() * (99 - 2 + 1)) + 2;
15
16    return new Estimate(name, value);
17  }
18
19  const list: Estimate[] = [new Estimate('최저 추정', 1), new Estimate('최대 추정', 100)];
20
21  for (let i = 0; i < 50; i++) {
22    list.push(generateEstimate());
23  }
24
25  shuffle(list);
26
27  const devs: string[] = planningPoker.identifyExtremes(list);
28
29  expect(devs).toEqual(expect.arrayContaining(['최저 추정', '최대 추정']));
30});
31

1it('중복이 존재하는 추정', () => {
2  const list: Estimate[] = [
3    new Estimate('Mauricio', 10),
4    new Estimate('Arie', 5),
5    new Estimate('Andy', 10),
6    new Estimate('Frank', 7),
7    new Estimate('Annibale', 5),
8  ];
9
10  const devs: string[] = planningPoker.identifyExtremes(list);
11
12  expect(devs).toEqual(expect.arrayContaining(['Mauricio', 'Arie']));
13});
14

1public identifyExtremes(estimates: Estimate[] | null): string[] {
2  if (!estimates) {
3    throw new IllegalArgumentException("Estimates can't be null")
4  }
5  if (estimates.length <= 1) {
6    throw new IllegalArgumentException(
7      'There has to be more than 1 estimate in the list',
8    )
9  }
10  let lowestEstimate: Estimate | null = null
11  let highestEstimate: Estimate | null = null
12  for (const estimate of estimates) {
13    if (!highestEstimate || estimate.estimate > highestEstimate.estimate) {
14      highestEstimate = estimate
15    }
16    if (!lowestEstimate || estimate.estimate < lowestEstimate.estimate) {
17      lowestEstimate = estimate
18    }
19  }
20  if (
21    !lowestEstimate ||
22    !highestEstimate ||
23    lowestEstimate === highestEstimate
24  ) {
25    return []
26  } // 1
27  return [lowestEstimate.developer, highestEstimate.developer]
28}
29

1. 만약 최저 추정 객체와 최대 추정 객체가 같다면 모든 추정값이 같으므로 빈 배열을 반환한다.

1it('allDevelopersWithTheSameEstimate', () => {
2  const list: Estimate[] = [
3    new Estimate('Mauricio', 10),
4    new Estimate('Arie', 10),
5    new Estimate('Andy', 10),
6    new Estimate('Frank', 10),
7    new Estimate('Annibale', 10),
8  ];
9
10  const devs: string[] = planningPoker.identifyExtremes(list);
11
12  expect(devs).toEqual([]);
13});
14

효율적인 소프트웨어 테스트

개발 과정에서의 효율적인 테스트

1. 기능 개발은 요구사항 을 받는 것으로부터 시작한다. 요구사항을 분석 한 이후 코드를 작성하기 시작한다.
2. 시능 개발을 유도하기 위해 테스트 주도 개발 과정을 반복한다. 이 과정에서 개발자는 코드의 타당함에 대한 피드백을 얻으며 리팩토링을 수행한다.
3. 요구사항은 종종 매우 크기에 여러 단위(클래스 or 메서드)를 만들게 된다. 각 단위는 다른 계약 을 가지며 서로 어율려 전체 기능을 구성한다. 클래스를 테스트하는 것은 어렵기에 항상 테스트 가능성 을 염두에 두고 설계한다.
4. 개발자가 단위와 요구사항을 전부 충족한 이후 도메인 테스트, 경계 테스트, 구조적 테스트 기법으로 각 단위를 테스트한다.
5. 시스템에는 대규모 테스트 (통합 테스트 or 시스템 테스트)가 필요한 부분이 있다. 개발자는 대규모 테스트를 위해 기존의 테스트 기법을 사용한다.
6. 개발자는 다양한 기법으로 테스트 케이스를 만들고 지능형 테스트 도구를 사용해 케이스를 찾아낸다.

• 테스트와 기능을 분리함으로써 기능을 코딩할 때 코너 케이스를 생각하지 않는다.
• 상용 버전에서의 버그의 비용은 종종 예방하는 비용보다 훨씬 더 크다.
• 테스트를 설계하는 것과 실행하는 것을 명확히 구분하자.
• 완벽한 테스트는 불가하다. (300개의 플래그에 두가지 값이 가능하다면 2의 300승의 케이스가 존재한다.) 따라서 우리는 효율적인 테스트가 필요하다.
• 프로그램을 테스트 하는 일은 버그가 존재하지 않다는 것이 아니라 버그가 존재하는지를 보여주는 것을 목표로 한다.

테스트 수준

단위 테스트

장점

• 단위 테스트는 빠르다.
• 단위 테스트는 다루기 쉽다.
• 단위 테스트는 작성하기 쉽다.

단점

• 단위 테스트는 현실성이 떨어진다.
• 단위 테스트는 잡을 수 없는 종류의 버그가 존재한다.

통합 테스트

시스템 테스트