1
import { Injectable } from '@nestjs/common'
2

3
@Injectable()
4
export class MathServerice {
5
  add(a: number, b: number): number {
6
    return a + b
7
  }
8
}

1
import { Test, TestingModule } from '@nestjs/testing'
2
import { MathService } from './math.service'
3

4
describe('MathService', () => {
5
  let service: MathService
6

7
  beforeEach(async () => {
8
    const module: TestingModule = await Test.createTestingModule({
9
      providers: [MathService],
10
    }).compile()
11

12
    service = module.get<MathService>(MathService)
13
  })
14

15
  it('should be defined', () => {
16
    expect(service).toBeDefined() // service가 정의되어 있는지 확인
17
  })
18

19
  it('should return correct sum of two numbers', () => {
20
    const result = service.add(2, 3)
21
    expect(result).toEqual(5) // 인풋에 대한 아웃풋을 테스트
22
  })
23

24
  it('should handle negative numbers', () => {
25
    const result = service.add(-1, 3)
26
    expect(result).toEqual(-4) // 다양한 케이스를 테스트
27
  })
28
})

1
PASS src/math.service.spec.ts
2
  MathService
3
    √ should be defined (5 ms)
4
    √ should return correct sum of two numbers (1 ms)
5
    √ should handle negative numbers (1 ms)
6

7
Test Suites: 1 passed, 1 total
8
Tests:       3 passed, 3 total
9
Snapshots:   0 total
10
Time:        1.015 s

1
test('two plus two is four', () => {
2
  // expect() 함수의 아규먼트가
3
  // toBe() 함수의 아규먼트와 같은지 확인한다
4
  expect(2 + 2).toBe(4)
5
})

1
const can1 = {
2
  flavor: 'grapefruit',
3
  ounces: 12,
4
}
5
const can2 = {
6
  flavor: 'grapefruit',
7
  ounces: 12,
8
}
9

10
describe('Test', () => {
11
  test('have all the same properties', () => {
12
    expect(can1).toEqual(can2)
13
  })
14
  test('are the exact same can', () => {
15
    expect(can1).not.toBe(can2)
16
  })
17
})

1
test('adding works sanely with decimals', () => {
2
  // Fall! (0.30000000000000004 !== 0.3)
3
  expect(0.2 + 0.1).toBe(0.3)
4
})

1
test('adding works sanely with decimals', () => {
2
  expect(0.2 + 0.1).toBeCloseTo(0.3, 5)
3
})

1
function dringAll(callback, flavour) {
2
  if (flavour !== 'octopus') {
3
    callback(flavour)
4
  }
5
}
6

7
describe('Test', () => {
8
  test('drinks something lemon-flavoured', () => {
9
    const drink = jest.fn()
10
    dringAll(drink, 'lemon')
11
    expect(drink).toHaveBeenCalled()
12
  })
13

14
  test('does not drink something octopus-flavoured', () => {
15
    const drink = jest.fn()
16
    dringAll(drink, 'octopus')
17
    expect(drink).not.toHaveBeenCalled()
18
  })
19
})

1
test('drink returns expected nth calls', () => {
2
  const beverage1 = { name: 'Lemon' }
3
  const beverage2 = { name: 'Orange' }
4
  const drink = jest.fn(beverage => beverage.name)
5

6
  drink(beverage1)
7
  drink(beverage2)
8

9
  expect(drink).toHaveNthReturnedWith(1, 'Lemon')
10
  expect(drink).toHaveNthReturnedWith(2, 'Orange')
11
})

1
describe('my beverage', () => {
2
  test('is delicious and not sour', () => {
3
    const myBeverage = { delicious: true, sour: false }
4
    expect([myBeverage, ...]).toContainEqual(myBeverage)
5
  })
6
})

1
const houseForSale = {
2
  bath: true,
3
  bedrooms: 4,
4
  kitchen: {
5
    amenities: ['oven', 'stove', 'washer'],
6
    area: 20,
7
    wallColor: 'white',
8
    'nice.oven': true,
9
  },
10
  liveingroomm: {
11
    amenities: [
12
      {
13
        couch: [
14
          ['large', { dimensions: [20, 20] }],
15
          ['small', { dimensions: [10, 10] }],
16
        ],
17
      },
18
    ],
19
  },
20
  'ceiling.height': 2,
21
}

1
test('this house has my desired features', () => {
2
  expect(houseForSale).toHaveProperty('bath')
3
  expect(houseForSale).toHaveProperty('bedrooms', 4)
4

5
  expect(houseForSale).not.toHaveProperty('pool')
6

7
  // '.'를 사용해서 깊게 레퍼런싱하기
8
  expect(houseForSale).toHaveProperty('kitchen.area', 20)
9
  expect(houseForSale).toHaveProperty('kitchen.amenities', ['oven', 'stove', 'washer'])
10

11
  expect(houseForSale).not.toHaveProperty('kitchen.open')
12

13
  // Array를 사용해서 깊게 레퍼런싱하기
14
  expect(houseForSale).toHaveProperty(['kitchen', 'area'], 20)
15
  expect(houseForSale).toHaveProperty(
16
    ['kitchen', 'amenities'], //
17
    ['oven', 'stove', 'washer'],
18
  )
19
  expect(houseForSale).toHaveProperty(['kitchen', 'amenities', 0], 'oven')
20
  expect(houseForSale).toHaveProperty(
21
    'liveingroomm.amenities[0].couch[0][1].dimensions[0]', //
22
    20,
23
  )
24
  expect(houseForSale).toHaveProperty(['kitchen', 'nice.oven'])
25
  expect(houseForSale).not.toHaveProperty(['kitchen', 'open'])
26

27
  // 키값 자체에 '.'이 있는 경우 Array 사용
28
  expect(houseForSale).toHaveProperty(['ceiling.height'], 'tall')
29
})

1
function drinkFlavor(flavor) {
2
  if (flavor === 'octopus') {
3
    throw new DisgustingFlavorError('으악 문어 노맛이야')
4
  }
5
}

1
test('throws on octopus', () => {
2
  function drinkOctopus() {
3
    drinkFlavor('octopus')
4
  }
5

6
  // 에러메시지 어딘가에 '노맛'이라고 써져있는지 확인한다.
7
  expect(drinkOctopus).toThrow(/노맛/)
8
  expect(drinkOctopus).toThrow('노맛')
9

10
  // 정확한 문장을 테스트한다.
11
  expect(drinkOctopus).toThrow(/^으악 문어 노맛이야!$/)
12
  expect(drinkOctopus).toThrow(new Error('으악 문어 노맛이야!'))
13

14
  // DisgustingFlavorError 타입의 에러가 던져지는걸 확인한다.
15
  expect(drinkOctopus).toThrow(DisgustingFlavorError)
16
})

1
describe('arrayContaining', () => {
2
  const expected = ['Alice', 'Bob']
3

4
  it('matches even if received contains additional elements', () => {
5
    expect(['Alice', 'Bob', 'Eve']).toEqual(expect.arrayContaining(expected))
6
  })
7
})

1
test('flavor is not coconut', () => {
2
  expect('apple').not.toBe('coconut')
3
})

1
test('resolves to lemon', () => {
2
  // make sure to add a return statement
3
  return expect(Promise.resolve('lemon')).resolves.toBe('lemon')
4
})

1
test('rejects to octopus', () => {
2
  return expect(Promise.reject(new Error('octopus'))).rejects.toThrow('octopus')
3
})

1
import { Test, TestingModule } from '@nestjs/testing'
2
import { UserService } from './user.service'
3
import { UserRepository } from './user.repository'
4

5
describe('UserService with Mock', () => {
6
  let userService: UserService
7
  let userRepositoryMock: { findById: jest.Mock }
8

9
  beforeEach(async () => {
10
    userRepositoryMock = { findById: jest.fn() } // Mock  생성하기
11

12
    const module: TestingModule = await Test.createTestingModule({
13
      providers: [
14
        UserService,
15
        {
16
          provide: UserRepository,
17
          useValue: userRepositoryMock, // Mock 주입하기
18
        },
19
      ],
20
    }).compile()
21

22
    userService = module.get<UserService>(UserService)
23
  })
24

25
  it('should call findById on UserRepository', () => {
26
    const userId = '1'
27
    userService.findUserById(userId)
28

29
    // 실행된걸 확인
30
    expect(userRepositoryMock.findById).toHaveBeenCalledWith(userId)
31

32
    // 한번만 불린걸 확인
33
    expect(userRepositoryMock.findById).toHaveBeenCalledTimes(1)
34
  })
35
})

1
import { Test, TestingModule } from '@nestjs/testing'
2
import { UserService } from './user.service'
3
import { UserRepository } from './user.repository'
4

5
describe('UserService with Stub', () => {
6
  let userService: UserService
7

8
  beforeEach(async () => {
9
    const userRepositoryStub = {
10
      findById: (id: string) => ({ id, name: 'Stubbed User' }), // Stub 생성하기
11
    }
12

13
    const module: TestingModule = await Test.createTestingModule({
14
      providers: [
15
        UserService,
16
        {
17
          provide: UserRepository,
18
          useValue: userRepositoryStub, // Stub 주입하기
19
        },
20
      ],
21
    }).compile()
22

23
    userService = module.get<UserService>(UserService)
24
  })
25

26
  it('should return the stubbed user', () => {
27
    const userId = '1'
28
    const result = userService.findUserById(userId)
29

30
    // 변환값 검증
31
    expect(result).toEqual({ id: userId, name: 'Stubbed User' })
32
  })
33
})

1
import { Test, TestingModule } from '@nestjs/testing'
2
import { UserService } from './user.service'
3
import { UserRepository } from './user.repository'
4

5
// Faks 생성
6
class FakeUserRepository {
7
  private user = [{ id: '1', name: 'Fake User' }]
8

9
  findById(id: string) {
10
    return this.users.find(user => user.id === id) || null
11
  }
12
}
13

14
describe('UserService with Fake', () => {
15
  let userService: UserService
16

17
  beforeEach(async () => {
18
    const module: TestingModule = await Test.createTestingModule({
19
      providers: [
20
        UserService,
21
        {
22
          provide: UserRepository,
23
          useClass: FakeUserRepository, // Fake 주입하기
24
        },
25
      ],
26
    }).compile()
27

28
    userService = module.get<UserService>(UserService)
29
  })
30

31
  it('should return the fake user', () => {
32
    const userId = '1'
33
    const result = userService.findUserById(userId)
34

35
    // 결과값 검증
36
    expect(result).toEqual({ id: userId, name: 'Fake User' })
37
  })
38

39
  it('should return null if user not found', () => {
40
    const userId = '2'
41
    const result = userService.findUserById(userId)
42

43
    // 결과값 검증
44
    expect(result).toBeNull()
45
  })
46
})

1
import { Test, TestingModule } from '@nestjs/testing'
2
import { UserService } from './user.service'
3
import { UserRepository } from './user.repository'
4

5
describe('UserService with Mock', () => {
6
  let userService: UserService
7
  let userRepositoryMock: { findById: jest.Mock }
8

9
  beforeEach(async () => {
10
    userRepositoryMock = { findById: jest.fn() } // Mock  생성하기
11

12
    const module: TestingModule = await Test.createTestingModule({
13
      providers: [
14
        UserService,
15
        {
16
          provide: UserRepository,
17
          useValue: userRepositoryMock, // Mock 주입하기
18
        },
19
      ],
20
    }).compile()
21

22
    userService = module.get<UserService>(UserService)
23
  })
24

25
  it('should call findById on UserRepository', () => {
26
    const userId = '1'
27
    userService.findUserById(userId)
28

29
    // 실행된걸 확인
30
    expect(userRepositoryMock.findById).toHaveBeenCalledWith(userId)
31

32
    // 한번만 불린걸 확인
33
    expect(userRepositoryMock.findById).toHaveBeenCalledTimes(1)
34
  })
35
})

1
const mockFn = jest.fn()
2

3
const a = new mockFn()
4
const b = new mockFn()
5

6
mockFn.mock.instances[0] === a // true
7
mockFn.mock.instances[1] === b // true

1
const mockFn = jest.fn(scalar => 42 + scalar)
2

3
mockFn(0) // 42
4
mockFn(1) // 43
5

6
mockFn.mockImplementation(scalar => 36 + scalar)
7

8
mockFn(2) // 38
9
mockFn(3) // 39

1
jest.fn(function () {
2
  return this
3
})

1
jest.fn().mockImplementation(() => value)

1
jest.fn().mockImplementation(() => Promise.resolve(value))

1
jest.fn().mockImplementation(() => Promise.reject(value))

1
import { CatsController } from './cats.controller'
2
import { CatsService } from './cats.service'
3

4
describe('CatsController', () => {
5
  let catsController: CatsController
6
  let catsService: CatsService
7

8
  beforeEach(() => {
9
    catsService = new CatsService()
10
    catsController = new CatsController(catsService)
11
  })
12

13
  describe('findAll', () => {
14
    it('should return an array of cats', async () => {
15
      const result = ['test']
16
      jest.spyOn(catsService, 'findAll').mockImplementation(() => result)
17

18
      expect(await catsController.findAll()).toBe(result)
19
    })
20
  })
21
})

1
import { Test } from '@nestjs/testing'
2
import { CatsController } from './cats.controller'
3
import { CatsService } from './cats.service'
4

5
describe('CatsController', () => {
6
  let catsController: CatsController
7
  let catsService: CatsService
8

9
  beforeEach(async () => {
10
    const module = await Test.createTestingModule({
11
      controllers: [CatsController],
12
      providers: [CatsService],
13
    }).compile()
14

15
    catsService = modulRef.get<CatsService>(CatsService)
16
    catsController = moduleRef.get<CatsController>(CatsController)
17
  })
18

19
  describe('findAll', () => {
20
    it('should return an array of cats', async () => {
21
      const result = ['test']
22
      jest.spyOn(catsService, 'findAll').mockImplementation(() => result)
23

24
      expect(await catsController.findAll()).toBe(result)
25
    })
26
  })
27
})

1
@Controller('uesrs')
2
export class UsersController {
3
  constructor(private readonly usersService: UsersService) {}
4

5
  @Get(':id')
6
  async getUserById(@Param('id', ParseIntPipe) id: number): Promise<User> {
7
    return this.usersService.findUserById(id)
8
  }
9
}

1
@Injectable()
2
export class UsersService {
3
  constructor(
4
    @InjectRepository(User)
5
    private readonly userRepository: Repository<User>,
6
  ) {}
7

8
  async findUserById(id: number): Promise<User> {
9
    if (id === '2') return null
10

11
    return await this.userRepository.findOne({
12
      where: { id },
13
    })
14
  }
15
}

1
describe('UserController', () => {
2
  let usersController: UsersController
3
  let usersService: UsersService
4

5
  beforeEach(async () => {
6
    const module: TestingModule = await Test.createTestingModule({
7
      controllers: [UsersController],
8
      providers: [
9
        {
10
          provide: UsersService,
11
          useValue: {
12
            findUserById: jest.fn(),
13
          },
14
        },
15
      ],
16
    }).compile()
17

18
    usersService = module.get<UsersService>(UsersService)
19
    usersController = module.get<UsersController>(UsersController)
20
  })
21

22
  it('should call UserService.findUserById with the correct parameter', async () => {
23
    const id = '1'
24
    const userServiceSpy = jest
25
      .spyOn(usersService, 'findUserById') //
26
      .mockResolvedValueOnce({ id, name: 'John Doe' })
27
    const result = userController.getUserById(id)
28

29
    expect(userServiceSpy).toHaveBeenCalledWith(id)
30
    expect(result).toEqual({ id, name: 'John Doe' })
31
  })
32
})

1
@Controller('users')
2
export class UsersController {
3
  constructor(private readonly usersService: UsersService) {}
4

5
  @Get(':id')
6
  async getUserById(@Param('id', ParseIntPipe) id: number): Promise<User> {
7
    return this.usersService.findUserById(id)
8
  }
9
}

1
@Injectable()
2
export class UsersService {
3
  constructor(
4
    @InjectRepository(User)
5
    private readonly userRepository: Repository<User>,
6
  ) {}
7

8
  async findUserById(id: number): Promise<User> {
9
    if (id === '2') return null
10

11
    return await this.userRepository.findOne({
12
      where: { id },
13
    })
14
  }
15
}

1
describe('UserController (Integration)', () => {
2
  let userController: UsersController
3
  let usersService: UsersService
4

5
  beforeEach(async () => {
6
    const module: TestingModule = await Test.createTestingModule({
7
      controllers: [UsersController],
8
      providers: [UsersService],
9
    }).compile()
10

11
    userController = module.get<UsersController>(UsersController)
12
    usersService = module.get<UsersService>(UsersService)
13
  })
14

15
  it('should return user data for a valid ID', () => {
16
    const id = '1'
17
    const result = userController.getUserById(id)
18
    expect(result).toEqual({ id: '1', name: 'John Doe' })
19
  })
20

21
  it('should return null for an invalid ID', () => {
22
    const id = '2'
23
    const result = userController.getUserById(id)
24
    expect(result).toBeNull()
25
  })
26
})

1
describe('UserController (E2E)', () => {
2
  let app: INestApplication
3

4
  beforeAll(async () => {
5
    const moduleFixture: TestingModule = await Test.createTestingModule({
6
      imports: [AppModule],
7
    }).compile()
8

9
    app = moduleFixture.createNestApplication()
10
    await app.init()
11
  })
12

13
  it('/users/:id (GET) - should return user data for a valid ID', async () => {
14
    const id = '1'
15
    const response = await request(app.getHttpServer()).get(`/users/${id}`).expect(200)
16

17
    expect(response.body).toEqual({ id: '1', name: 'John Doe' })
18
  })
19

20
  it('/users/:id (GET) - should return 404 for an invalid ID', async () => {
21
    const id = '2'
22
    await request(app.getHttpServer()).get(`/users/${id}`).expect(404)
23
  })
24

25
  afterAll(async () => {
26
    await app.close()
27
  })
28
})

1
// Statement
2
const sum = (a, b) => a + b
3
// Statement
4
console.log(sum(1, 2))

1
if (x > 10) {
2
  // 하나의 분기
3
  console.log('x는 10보다 큽니다')
4
} else {
5
  // 하나의 분기
6
  console.log('x는 10 이하입니다')
7
}

1
function add(a, b) {
2
  // 함수입니다.
3
  return a + b
4
}
5

6
function subtract(a, b) {
7
  // 함수입니다.
8
  return a - b
9
}

1
const multiply = (a, b) => {
2
  // 라인입니다.
3
  return a * b
4
}
5

6
// 라인
7
console.log(multiply(2, 3))