Mock
Mock ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ ์ด์
ํ ์คํธ๋ ์ค์ ์คํ ํ๊ฒฝ๊ณผ ์ ์ฌํ ์๋ก ์ฌํ์ฑ์ด ๋๋ค.
ํ์ง๋ง ์ฌํ์ฑ์ ๋์ด๋ค๋ณด๋ฉด ์คํ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๊ฑฐ๋ ํ๊ฒฝ ๊ตฌ์ถ์ด ์ด๋ ค์์ง๋ ๊ฒฝ์ฐ๊ฐ ์๋ค.
๋ํ์ ์ผ๋ก ์น API ๋ฐ์ดํฐ๋ฅผ ๋ค๋ค์ผํ๋ ๊ฒฝ์ฐ ๋คํธ์ํฌ ์ค๋ฅ์๊ฐ์ด ์ ์ดํ ์ ์๋ ๋ถ๋ถ์์ ์คํจํ ์ ์์
ํ ์คํธํ๋ ๋์์ ์น API ์์ฒด๊ฐ ์๋ ์๋ต ๋ฐ์ดํฐ์ ๋ํ ์ฒ๋ฆฌ๋ผ๋๊ฒ์ ๋ช ์ฌ
์ค์ API ์๋ต๊ฐ ๋์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ชฉ ๊ฐ์ฒด์ด๋ค.
๋ชฉ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ฉด ํ ์คํธ๊ฐ ์ด๋ ค์ด ๋ถ๋ถ์ ํ ์คํธ๋ฅผ ๊ฐ๋ฅํ๊ฒ ํ๊ณ ๋์ฑ ํจ์จ์ ์ธ ํ ์คํธ๊ฐ ๊ฐ๋ฅํด์ง๋ค.
๋ชฉ ๊ฐ์ฒด ์ฉ์ด
stub
,spy
๋ฑ์ ๋ชฉ ๊ฐ์ฒด๋ฅผ ์ํฉ์ ๋ฐ๋ผ ์ธ๋ถํํ ๊ฐ์ฒด์ ๋ช ์นญ๊ฐ๋ฐ ์ธ์ด์ ์๊ด์์ด ํ ์คํธ ์๋ํ ๊ด๋ จ ๋ฌธํ์์ ์ ์ํ ์ฉ์ด
Stub
์คํ ์ ์ฃผ๋ก ๋์ญ์ผ๋ก ์ฌ์ฉํ๋ค. 1) ์์กด์ค์ธ ์ปดํฌ๋ํธ์ ๋์ญ 2) ์ ํด์ง ๊ฐ์ ๋ฐํํ๋ ์ฉ๋ 3) ํ ์คํธ ๋์์ ํ ๋นํ๋ ์ ๋ ฅ๊ฐ
์ฆ, ํ ์คํธ ์ฝ๋์์ ์ค์ ๋ก ์์กดํ๋ ๋ฐ์ดํฐ๋ ๊ธฐ๋ฅ์ ๋์ฒดํ๋ ๋๋ฏธ ๋ฐ์ดํฐ๋ฅผ ๋ฐํํ๋ ์ญํ
ํ ์คํธ ๋์์ด ์์กด์ค์ธ ์ปดํฌ๋ํธ์ ํ ์คํธํ๊ธฐ ์ด๋ ค์ด ๋ถ๋ถ์ด ์์ ๋
์น API์ ์์กด์ค์ธ ๋์์ ํ ์คํธํ๋ ๊ฒฝ์ฐ
"์น API์์ ์ด๋ฐ ๊ฐ์ ๋ฐํ๋ฐ์์ ๋๋ ์ด๋ ๊ฒ ์๋ํด์ผ ํ๋ค." ์ ๊ฐ์ ํ ์คํธ์ ์คํ ์ ์ฌ์ฉํ๋ค.
Spy
์คํ์ด๋ ์ฃผ๋ก ๊ธฐ๋กํ๋ ์ฉ๋
1) ํจ์๋ ๋ฉ์๋์ ํธ์ถ ๊ธฐ๋ก
2) ํธ์ถ๋ ํ์๋ ์คํ ์ ์ฌ์ฉํ ์ธ์ ๊ธฐ๋ก
3) ํ ์คํธ ๋์์ ์ถ๋ ฅ ํ์ธ
ํ ์คํธ ๋์ ์ธ๋ถ์ ์ถ๋ ฅ์ ๊ฒ์ฆํ ๋ ์ฌ์ฉํ๋ค.
์ธ์๋ก ๋ฐ์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๊ฒ์ฆํ๋ ๊ฒ
์ฝ๋ฐฑํจ์๊ฐ ์คํ๋ ํ์
์คํ ์ ์ฌ์ฉํ ์ธ์
์๋ํ ๋๋ก ์ฝ๋ฐฑ์ด ํธ์ถ๋๋์ง ๊ฒ์ฆ
Jest์ ์ฉ์ด ํผ๋
์ ์คํธ์ API๋ xUnit ํ ์คํธํจํด ์ ์ฉ์ด ์ ์๋ฅผ ์ถฉ์คํ ๋ฐ๋ฅด์ง ์๋๋ค.
์ ์คํธ๋ ์คํ , ์คํ์ด๋ฅผ ๊ตฌํํ ๋
jest.mock
(๋ชฉ ๋ชจ๋) ํน์jest.fn
,jest.spyOn
(๋ชฉ ํจ์) ๋ผ๋ API๋ฅผ ์ฌ์ฉํ๋ค.์ ์คํธ๋ ์ด๋ฅผ ๊ตฌํํ ํ ์คํธ ๋์ญ์ ๋ชฉ ๊ฐ์ฒด๋ผ๊ณ ๋ถ๋ฅด๋ ๋ฑ xUnit ํ ์คํธ ํจํด์์ ์ ์ํ ์ฉ์ด์๋ ๋ค๋ฅธ ๋ถ๋ถ์ด ๋ง์
์คํ ํน์ ์คํ์ด๋ก์ ์ฌ์ฉํ๋ ๋ช ํํ ์ด์ ๊ฐ ์์ ๋๋ฅผ ์ ์ธํ๊ณ ๋ ๋ชฉ ๊ฐ์ฒด๋ผ๊ณ ๋ถ๋ฅด์.
Jest๋ก ๋ชฉ ๋ชจ๋์ ํ์ฉํ์ฌ ์คํ
๊ตฌํํ๊ธฐ
๋จ์ ํ ์คํธ๋ ํตํฉ ํ ์คํธ๋ฅผ ์์ฑํ ๋ ๊ตฌํ์ด ์์ฑ๋์ด ์์ง ์๊ฑฐ๋ ์์ ์ด ํ์ํ ๋ชจ๋์ ์์กด์ค์ธ ๊ฒฝ์ฐ๊ฐ ์๋ค
์ด๋ ๋ชฉ ๋ชจ๋๋ก ๋์ฒดํ๋ฉด ํ ์คํธํ ์ ์์๋ ๋์์ ํ ์คํธ ๊ฐ๋ฅํ๊ฒ ํ๋ค.
export function greet(name: string) {
return `Hello ${name}.`;
}
export function sayGoodBye(name: string) {
throw new Error("๋ฏธ๊ตฌํ")
}
import { greet } from './greet';
jest.mock("./greet"); // jest.mock์ด ํ
์คํธ ์ ์ ํธ์ถ๋๋ฉด์ ํ
์คํธํ ๋ชจ๋์ ๋์ฒดํจ
test("์ธ์ฌ๋ง์ ๋ฐํํ์ง ์๋๋ค(์๋ ๊ตฌํ๊ณผ ๋ค๋ฅด๊ฒ)", () => {
expect(greet("woong")).toBe(undefined)
})
๋ชจ๋์ ์คํ
์ผ๋ก ๋์ฒดํ๊ธฐ
jest.mock
์ ๋ ๋ฒ์งธ ์ธ์์๋ ๋์ฒดํ ํจ์๋ฅผ ๊ตฌํํ ์ ์๋ค.๋ชจ๋์ ์ผ๋ถ๋ฅผ ํ ์คํธ์์ ๋์ฒดํ๋ฉด ์์กด ์ค์ธ ๋ชจ๋์ ํ ์คํธ๊ฐ ์ด๋ ต๋๋ผ๋ ํ ์คํธ๊ฐ ๊ฐ๋ฅํ๊ฒ ๋ง๋ค ์ ์๋ค.
import { greet, sayGoodBye } from './greet';
// ./greet ๋ชจ๋์ ๋ชจ๋ ๋์ฒดํ๊ฒ ๋์ด ๋ฐ๋ก ์ค์ ํ์ง ์์ผ๋ฉด undefined๋ฅผ ๋ฐํํ๊ฒ ๋๋ค.
jest.mock("./greet", () => ({
sayGoodBye: (name: string) => `Good bye, ${name}`,
}))
test("์๋ณ ์ธ์ฌ๋ฅผ ๋ฐํํ๋ค(์๋ ๊ตฌํ๊ณผ ๋ค๋ฅด๊ฒ)", () => {
const message = `${sayGoodBye("woong")} See you.`;
expect(message).toBe("Good bye. woong See you.");
})
๋ชจ๋ ์ผ๋ถ๋ฅผ ์คํ
์ผ๋ก ๋์ฒดํ๊ธฐ
jest.requireActual
ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ ๋ชจ๋์ ๊ตฌํ์import
ํ ์ ์๋ค.
import { greet, sayGoodBye } from './greet';
jest.mock("./greet", () => ({
...jest.requireActual('./greet'),
sayGoodBye: (name: string) => `Good bye, ${name}.`
}))
test("์ธ์ฌ๋ง์ ๋ฐํํ๋ค.(์๋ ๊ตฌํ๊ณผ ๋์ผํ๊ฒ)", () => {
expect(greet("woong")).toBe("Hello woong");
})
๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋์ฒดํ๊ธฐ
์์ ์ด ํ์ํ ๋ชจ๋์ ์ผ๋ถ๋ฅผ ๋์ฒดํ๋ ๋ฐฉ๋ฒ
์ค๋ฌด์์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋์ฒดํ ๋ ๋ชฉ ๋ชจ๋์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ค.
// next/router ์์กด ๋ชจ๋ ๋์ next-router-mock ์ด๋ผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ์ฉ
jest.mock("next/router", () => require("next-router-mock"));
์น API ๋ชฉ ๊ฐ์ฒด ๊ธฐ์ด
์น ์ ํ๋ฆฌ์ผ์ด์ ์์๋ ์น API ์๋ฒ์ ํต์ ํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ทจ๋ํ๊ณ ๊ฐฑ์ ํ๋ ์์ ์ ํ์
ํ ์คํธํ ๋๋ ์น API ๊ด๋ จ ์ฝ๋๋ฅผ ์น API ํด๋ผ์ด์ธํธ์ ๋์ญ์ธ ์คํ ์ผ๋ก ๋์ฒดํ์ฌ ํ ์คํธ๋ฅผ ์์ฑํ๋ค.
์คํ ์ด ์ค์ ์๋ต์ ์๋์ง๋ง ์๋ต ์ ํ์ ๊ด๋ จ ์ฝ๋๋ฅผ ๊ฒ์ฆํ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
์น API ์๋ฒ๊ฐ ์์ผ๋ฉด API๋ฅผ ํธ์ถ์ด ํฌํจ๋ ๋ก์ง์ ํ ์คํธ๊ฐ ๋ถ๊ฐ๋ฅํ๋ค.
ํด๋น API ํธ์ถ ๋ถ๋ถ์ ์คํ ์ผ๋ก ๋์ฒดํ๋ฉด ์ค์ ์๋ฒ์ ์๋ต ์ฌ๋ถ ์๊ด์์ด ๋ฐ์ดํฐ ์ทจ๋๊ณผ ๊ด๋ จ๋ ๋ก์ง์ ํ ์คํธํ ์ ์๋ค.
import { getMyProfile } from "../fetchers";
export async function getGreet() {
const data = await getMyProfile();
if (!data.name) {
return `Hello, anonymouse user!`;
}
return `Hello, ${data.name}!`;
}
์น API๋ฅผ ํด๋ผ์ด์ธํธ ์คํ
๊ตฌํ
ํ์ ์คํฌ๋ฆฝํธ์ ์์ฑ์ด ์ข์
jest.spyOn
์ ์ฌ์ฉํด๋ณด์.
import * as Fetchers from "./fetchers";
jest.mock("./fetchers");
// jest.spyOn์ผ๋ก ํ
์คํธํ ๊ฐ์ฒด๋ฅผ ๋์ฒดํ๋ค. (ํ
์คํธํ ๊ฐ์ฒด -> Fetchers)
// jest.spyOn(ํ
์คํธํ ๊ฐ์ฒด, ํ
์คํธํ ํจ์ ์ด๋ฆ);
// *ํ
์คํธํ ๋์์ ์ ์๋์ง ์์ ํจ์ ์ด๋ฆ์ ์ง์ ํ๋ฉด ํ์
์ค๋ฅ ๋ฐ์
jest.spyOn(Fetcehrs, "getMyProfile")
๋ฐ์ดํฐ ์ทจ๋ ์ฑ๊ณต์ ์ฌํํ ํ
์คํธ
๋ฐ์ดํฐ ์ทจ๋์ด ์ฑ๊ณตํ์ ๋(resolve) ์๋ต์ผ๋ก ๊ธฐ๋ํ๋ ๊ฐ์ฒด๋ฅผ
mockResolvedValueOnce
์ ์ง์ ์ฌ๊ธฐ์ ์ง์ ํ ๊ฐ์ฒด๋ ํ์ ์์คํ ์ด ์ ์ฉ๋ ์ํ์ด๋ฏ๋ก ์ ์ง๋ณด์ ์์
test("๋ฐ์ดํฐ ์ทจ๋ ์ฑ๊ณต์: ์ฌ์ฉ์ ์ด๋ฆ์ด ์๋ ๊ฒฝ์ฐ", async () => {
// api๊ฐ resolve๋์ ๋์ ๊ฐ์ ์ฌํ
jest.spyOn(Fetchers, "getMyProfile").mockResolvedValueOnce({
id: "....",
eamil: "...",
});
await expect(getGreet()).resolves.toBe("Hello, anonymouse user!");
})
test("๋ฐ์ดํฐ ์ทจ๋ ์ฑ๊ณต์: ์ฌ์ฉ์ ์ด๋ฆ์ด ์๋ ๊ฒฝ์ฐ", async () => {
// api๊ฐ resolve๋์ ๋์ ๊ฐ์ ์ฌํ
jest.spyOn(Fetchers, "getMyProfile").mockResolvedValueOnce({
id: "....",
eamil: "...",
name: "woong",
});
await expect(getGreet()).resolves.toBe("Hello, woong!");
})
๋ฐ์ดํฐ ์ทจ๋ ์คํจ๋ฅผ ์ฌํํ ํ
์คํธ
export function getMyProfile(): Promise<Profile> {
return fetch("...").then(async (res) => {
const data = await res.json();
if (!res.ok) {
//200๋ฒ๋ ์ธ์ ์๋ต์ธ ๊ฒฝ์ฐ
throw data;
}
return data;
})
}
// ์ค๋ฅ ๊ฐ์ฒด
export const httpError: HttpError = {
err: { message: "internal server error" },
};
์ค๋ฅ ๊ฐ์ฒด๋ฅผ
mockRejectedValueOnce
์ธ์๋ก getMyProfile ํจ์์reject
๋ฅผ ์ฌํํ๋ ์คํ ์ ๊ตฌํ
test("๋ฐ์ดํฐ ์ทจ๋ ์คํจ์", async () => {
jest.spyOn(Fetchers, "getMyProfile").mockRejectedValueOnce(httpError)
await expect(getGreet()).rejects.toMatchObject({
err: {message: "internal server error" },
})
})
test("๋ฐ์ดํฐ ์ทจ๋ ์คํจ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ๋ฐ์ดํฐ์ ํจ๊ป ์์ธ๊ฐ throw๋๋ค.", async () => {
expect.assertions(1);
jest.spyOn(Fetchers, "getMyProfile").mockRejectedValueOnce(httpError)
try {
await getGreet();
} catch (err) {
expect(err).toMatchObject(httpError);
}
})
ํฝ์ค์ฒ
์๋ต์ ์ฌํํ๊ธฐ ์ํ ํ ์คํธ์ฉ ๋ฐ์ดํฐ๋ฅผ ์๋ฏธ
๋ชฉ ๊ฐ์ฒด ์์ฑ ํจ์
ํ ์คํธ์ ํ์ํ ์ค์ ์ ์ต๋ํ ์ ์ ๋งค๊ฐ๋ณ์๋ก ๊ต์ฒดํ ์ ์๊ฒ ๋ง๋๋ ์ ํธ๋ฆฌํฐ ํจ์
ํ ์คํธํ ๋๋ง๋ค
jest.spyOn
์ ์์ฑํ์ง ์์๋ ๋์ด ์ฝ๋๊ฐ ๊น๋ํด์ง๋ค.
๋ชฉ ํจ์๋ฅผ ์ฌ์ฉํ๋ ์คํ์ด
์ ์คํธ์ ๋ชฉ ํจ์๋ก ์คํ์ด๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ
์คํ์ด๋ ํ ์คํธ ๋์์ ๋ฐ์ํ ์ ์ถ๋ ฅ์ ๊ธฐ๋กํ๋ ๊ฐ์ฒด
์คํ์ด์ ๊ธฐ๋ก๋ ๊ฐ์ ๊ฒ์ฆํ์ฌ ์๋ํ ๋๋ก ๊ธฐ๋ฅ์ด ์๋ํ๋์ง ํ ์คํธํ ์ ์์
์คํ๋๋์ง ๊ฒ์ฆํ๊ธฐ
jest.fn
์ฌ์ฉํด์ ๋ชฉ ํจ์๋ฅผ ์์ฑ์์ฑํ ๋ชฉ ํจ์๋ ํ ์คํธ ์ฝ๋์์ ํจ์๋ก ์ฌ์ฉํ๋ฉฐ
tobeCalled
๋งค์ฒ๋ฅผ ์ฌ์ฉํ๋ฉด ์คํ ์ฌ๋ถ ๊ฒ์ฆ ๊ฐ๋ฅ
test("๋ชฉ ํจ์๊ฐ ์คํ๋๋ค.", () => {
const mockFn = jest.fn();
mocFn();
expect(mockFn).toBeCalled();
})
test("๋ชฉ ํจ์๊ฐ ์คํ๋์ง ์์๋ค.", () => {
const mockFn = jest.fn();
expect(mockFn).not.toBeCalled();
})
์คํ ํ์ ๊ฒ์ฆ
๋ชฉ ํจ์๋ ์คํ ํ์๋ฅผ ๊ธฐ๋กํ๋ค.
toHaveBeenCalledTimes
๋งค์ฒ๋ฅผ ์ฌ์ฉํ๋ฉด ํจ์๊ฐ ๋ช ๋ฒ ํธ์ถ๋๋์ง ๊ฒ์ฆ
test("๋ชฉ ํจ์๋ ์คํ ํ์๋ฅผ ๊ธฐ๋กํ๋ค", () => {
const mockFn = jest.fn();
mockFn();
expect(mockFn).toHaveBeenCalledTimes(1);
mockFn();
expect(mockFn).toHaveBeenCalledTimes(2);
})
์คํ ์ ์ธ์ ๊ฒ์ฆ
๋ชฉ ํจ์๋ ์คํ ์ ์ธ์๋ ๊ธฐ๋ก
toHaveBeenCalledWith
๋งค์ฒ๋ฅผ ์ฌ์ฉ
๋ชฉ ํจ์๋ ๋ค๋ฅธ ํจ์ ์์ ์์ฑํ ์๋ ์๋ค.
test("๋ชฉ ํจ์๋ ์์์๋ ์คํํ ์ ์๋ค.", () => {
const mockFn = jest.fn();
function greet() {
mockFn();
}
greet();
expect(mockFn).toHaveBeenCalledTimes(1);
})
test("๋ชฉ ํจ์๋ ์คํ ์ ์ธ์๋ฅผ ๊ธฐ๋กํ๋ค", () => {
const mockFn = jest.fn();
function greet(message: string) {
mockFn(message); // ์ธ์๋ฅผ ๋ฐ์ ์คํ
}
greet("hello"); // "hello"๋ฅผ ์ธ์๋ก ์คํ๋๊ฒ์ด mockFn์ ๊ธฐ๋ก๋๋ค.
expect(mockFn).toHaveBeenCalledWith("hello");
})
์คํ ์ ์ธ์๊ฐ ๊ฐ์ฒด์ผ ๋์ ๊ฒ์ฆ
์ธ์๊ฐ ๋ฌธ์์ด ๊ฐ์ ์์ํ์ด ์๋ ๋ฐฐ์ด์ด๋ ๊ฐ์ฒด์ผ ๋๋ ๊ฒ์ฆ์ด ๊ฐ๋ฅํ๋ค.
expect.objectContaining
๋ผ๋ ๋ณด์กฐ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด์ ์ผ๋ถ๋ง ๊ฒ์ฆํ ์ ์๋ค.๊ฐ์ฒด๊ฐ ๋๋ฌด ํฌ๋ฉด ์ผ๋ถ๋ง ๊ฒ์ฆํ ์ ๋ฐ์ ์๋ค.
test("expect.objectContaining๋ฅผ ์ฌ์ฉํ ๋ถ๋ถ ๊ฒ์ฆ", () => {
const mockFn = jest.fn();
checkConfig(mockFn);
expect(mockFn).toHaveBeenCalledWith(
expect.objectContaining({
feature: { spy: true },
})
)
})
ํ
์คํธ ์ค๋น
์ ๋ ฅ ๊ฐ์ ๋์ ์ผ๋ก ์์ฑํ ์ ์๋ ํฉํ ๋ฆฌ ํจ์
function inputFactory(input?: Partial<ArticleInput>) {
return {
tags: ["testing"],
title: "ํ์
์คํฌ๋ฆฝํธ ํ
์คํ
์์ฑ๋ฒ",
body: "...",
...input,
}
}
const input = inputFactory(); //์ ํจ์ฑ ๊ฒ์ฌ๋ฅผ ํต๊ณผํ๋ ๊ฐ์ฒด ๋ฐํ
const input = inputFactory({title: "", body: ""}); // ์ ํจ์ฑ ๊ฒ์ฌ์ ํต๊ณผํ์ง ๋ชปํ๋ ๊ฐ์ฒด ๋ฐํ
ํ์ฌ ์๊ฐ์ ์์กดํ๋ ํ
์คํธ
ํ์ฌ ์๊ฐ์ ์์กดํ๋ ๋ก์ง์ด ํ ์คํธ ๋์์ ํฌํจ๋๋ค๋ฉด ํ ์คํธ ๊ฒฐ๊ณผ๊ฐ ์คํ ์๊ฐ์ ์์กดํ๊ฒ ๋จ
ํน์ ์๊ฐ๋์๋ CI์ ํ ์คํธ ์๋ํ๊ฐ ์คํจํ๋ ๋ถ์์ ํ ํ ์คํธ๊ฐ ๋๋ค.
์ด๋ ํ ์คํธ ์คํ ํ๊ฒฝ์ ํ์ฌ ์๊ฐ์ ๊ณ ์ ํ๋ฉด ํญ์ ๋์ผํ ํ ์คํธ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
export function greetByTime() {
const hour = new Date().getHours();
if (hour < 12) {
return "good morning"
} else if (hour < 18) {
return "good afternoon",
} else {
return "good evening"
}
}
ํ์ฌ ์๊ฐ ๊ณ ์ ํ๊ธฐ
ํ ์คํธ ์คํ ํ๊ฒฝ์ ํ์ฌ ์๊ฐ์ ์์์ ์๊ฐ์ผ๋ก ๊ณ ์ ํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ ํจ์ ์ฌ์ฉ
jest.useFakeTimers
: ์ ์คํธ์ ๊ฐ์ง ํ์ด๋จธ๋ฅผ ์ฌ์ฉํ๋๋ก ์ง์jest.setSystemTime
: ๊ฐ์ง ํ์ด๋จธ์์ ์ฌ์ฉํ ํ์ฌ ์๊ฐ์ ์ค์ jest.useRealTimers
: ์ ์คํธ์ ์ค์ ํ์ด๋จธ๋ฅผ ์ฌ์ฉํ๋๋ก ์ง์ํ๋ ์์ ๋ณต๊ท ํจ์
beforeEach
, afterEach
๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ํ
์คํธ๋ง๋ค ์ฌ์ ์ค์ ์ฝ๋๋ฅผ ์ ๊ฑฐํ ์ ์๋ค.
describe("greetByTime(", () => {
beforeEach(() => {
jest.useFakeTimers();
})
afterEach(() => {
jest.useRealTimers();
})
test("์์นจ์๋ 'good morning'์ ๋ฐํํ๋ค", () => {
jest.setSystemTime(new Date(2023, 4, 23, 8, 0, 0));
expect(greetByTime()).toBe("good morning")
})
})
ํ
์คํธ ์ค์ ๊ณผ ํ๊ธฐ
ํ ์คํธ๋ฅผ ์คํํ๊ธฐ ์ ๊ณตํต์ผ๋ก ์ค์ ํด์ผ ํ ์์ ์ด ์๊ฑฐ๋ ํ ์คํธ ์ข ๋ฃ ํ์ ๊ณตํต์ผ๋ก ํ๊ธฐํ๊ณ ์ถ์ ์์ ์ด ์๋ ๊ฒฝ์ฐ
์ค์ ์์ ์
beforeAll
,beforeEach
๋ฅผํ๊ธฐ ์์ ์
afterAll
,afterEach
๋ฅผ ์ฌ์ฉ
beforeAll(() => console.log("1 - beforeAll"));
afterAll(() => console.log("1 - afterAll"));
beforeEach(() => console.log("1 - beforeEach"));
afterEach(() => console.log("1 - afterEach"));
test("", () => console.log("1 - test"));
describe("Scoped / Nested block", () => {
beforeAll(() => console.log("2 - beforeAll"));
afterAll(() => console.log("2 - afterAll"));
beforeEach(() => console.log("2 - beforeEach"));
afterEach(() => console.log("2 - afterEach")
test("", () => console.log("2 - test"));
})
// 1 - beforeAll
// 1 - beforeEach
// 1 - test
// 1 - afterEach
// 2 - beforeAll
// 1 - beforeEach
// 2 - beforeEach
// 2 - test
// 2 - afterEach
// 1 - afterEach
// 2 - afterAll
// 1 - afterAll
Last updated