Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

SpringMid18 phút đọc

Unit test với JUnit 5 và Mockito: test quyết định, không test dây nối

Ôn 13 thẻ
Trong bài này

Cụm bài Test trong Spring Boot: 1. Unit test với JUnit và Mockito · 2. Slice test và Testcontainers

Unit test tốt bắt được bug ở logic nghiệp vụ trong vài mili giây và cho bạn dám refactor; unit test tệ chỉ lặp lại code và vỡ mỗi khi đổi cách cài đặt. Bài này chỉ cách chọn cái đáng test, viết bằng JUnit 5/6 và Mockito, và review một bộ test do AI sinh ra. Ví dụ là UserServiceTest thật trong lab Spring Boot 4 (6 test, đều pass).

Sơ đồ tóm tắt:

flowchart TD
  A{"Code là gì?"} -->|"Quyết định"| B["Unit test"]
  A -->|"Dây nối"| C["Slice hoặc integration test"]
  B --> D["Arrange, Act, Assert"]
  D --> E["Stub cấp dữ liệu"]
  D --> F["Verify tác dụng phụ"]
  E --> G{"Xoá logic, test đỏ?"}
  F --> G
  G -->|"Không"| H["Test vô dụng"]
  G -->|"Có"| I["Đo bằng mutation testing"]

1. Vì sao developer phải tự viết test

Ý chính: test tự động là lưới an toàn cho thay đổi: mỗi lần sửa code, hàng trăm kịch bản chạy lại trong vài giây. Giá trị của nó tăng theo số lần code bị sửa, không theo số dòng test.

  • Regression: sửa bug A làm hỏng chức năng B. Test cũ đỏ ngay ở máy bạn, không đợi QA.
  • Refactor an toàn: đổi cấu trúc bên trong mà hành vi giữ nguyên; test (viết theo hành vi) vẫn xanh.
  • Tài liệu sống: tên test như rejectsDuplicateEmailWithoutHashingOrSaving mô tả quy tắc nghiệp vụ chính xác hơn wiki.
  • Fix bug bắt đầu bằng test: viết test tái hiện bug (đỏ), sửa (xanh), bug đó không quay lại được.

Không đáng viết unit test cho: getter/setter, code chỉ chuyển tiếp lời gọi, prototype sẽ vứt. Manual/exploratory testing vẫn cần cho UX; tự động hoá dành cho thứ lặp lại.

2. Kim tự tháp test và phản biện

Ý chính: kim tự tháp (nhiều unit, ít integration, rất ít E2E) là nguyên tắc chi phí, không phải tỉ lệ bắt buộc. Với service REST chủ yếu là CRUD, phần lớn rủi ro nằm ở chỗ nối với DB và HTTP, nên integration test chiếm nhiều hơn.

Loại Chạy Bắt được gì Giá
Unit ms, không Spring, không DB lỗi logic, nhánh, chuẩn hoá rẻ, dễ debug
Slice / integration trăm ms – giây mapping JSON, validation, query, transaction, security vừa
E2E giây – phút luồng đầu-cuối với UI/hạ tầng thật đắt, dễ flaky

Tỉ lệ 70/20/10 trong tài liệu là hình mẫu cho hệ thống nhiều logic. Hai phản biện hay gặp:

  • Testing trophy (Kent C. Dodds): trọng tâm là integration, vì nó cho nhiều tự tin nhất trên mỗi giờ viết.
  • Testing honeycomb (Spotify, cho microservice): ít unit “cô lập”, nhiều test trên ranh giới service với DB thật.

Cách chọn thực dụng: logic phức tạp thì unit test kỹ; phần “lấy từ DB, map, trả JSON” thì slice/integration test (phần 2).

3. Test cái gì ở mức unit

Ý chính: unit test có ý nghĩa khi method có quyết định: rẽ nhánh, tính toán, chuẩn hoá, thứ tự bắt buộc. Câu kiểm tra: “nếu tôi xoá logic này, test có đỏ không?”

Tài liệu khoá học nói “service không có logic thì unit test vô nghĩa” và lấy ví dụ findById(id).orElseThrow(...). Ví dụ này thực ra có một nhánh (tìm thấy / không thấy), chỉ là nhánh quá đơn giản và nằm sát dây nối. Quy tắc rõ hơn:

  • Unit test: quy tắc nghiệp vụ (email trùng thì từ chối), biến đổi dữ liệu (chuẩn hoá email, hash mật khẩu), thứ tự có ý nghĩa (kiểm tra trùng trước khi hash), tính toán (giá, thuế, ngày hết hạn).
  • Không unit test: method chỉ gọi repository rồi trả về; mapping annotation; query JPQL. Mock repository ở đây chỉ kiểm rằng code gọi… cái nó gọi.

4. Cấu trúc một test: AAA và cách đặt tên

Ý chính: mỗi test có ba khúc Arrange (chuẩn bị), Act (gọi đúng một hành vi), Assert (kiểm kết quả); BDD gọi là Given–When–Then. Tên test nói hành vi và kết quả, không nói tên method.

@Test
void rejectsDuplicateEmailWithoutHashingOrSaving() {
    // Arrange (Given): email đã tồn tại
    when(users.existsByEmailIgnoreCase("an@example.dev")).thenReturn(true);

    // Act + Assert (When/Then): bị từ chối, không hash, không lưu
    assertThatThrownBy(() -> service.create(req))
            .isInstanceOf(DuplicateResourceException.class)
            .hasMessageContaining("an@example.dev");
    verify(users, never()).save(any());
    verifyNoInteractions(encoder);
}
  • Một test, một lý do để đỏ. Nhiều assert được, miễn cùng một hành vi.
  • Không if/vòng lặp trong test; cần nhiều input thì dùng parameterized test.
  • Tên theo mẫu does_X_when_Y hoặc câu tiếng Anh; @DisplayName khi muốn tiếng Việt trong báo cáo.

5. JUnit 5/6: những gì dùng hằng ngày

Ý chính: JUnit Jupiter cho @Test, vòng đời @BeforeEach, nhóm bằng @Nested, nhiều input bằng @ParameterizedTest; assertion nên dùng AssertJ cho dễ đọc. Spring Boot 4 kéo JUnit 6 nhưng API Jupiter giữ nguyên, code JUnit 5 chạy không cần sửa.

Tính năng Dùng khi
@BeforeEach / @AfterEach tạo lại fixture cho mỗi test (JUnit tạo instance mới cho mỗi test)
@BeforeAll (static) khởi tạo đắt dùng chung: container, file lớn
@Nested + @DisplayName nhóm test theo method hoặc theo tình huống
@ParameterizedTest + @ValueSource / @CsvSource / @MethodSource cùng một quy tắc, nhiều input
assertThrows / assertThatThrownBy kiểm exception và message
@Disabled, @Tag("slow") tạm tắt có lý do, chọn nhóm test để chạy
@ParameterizedTest
@ValueSource(strings = {"AN@EXAMPLE.DEV", "  an@example.dev  ", "An@Example.Dev"})
void normalizesEmailVariants(String email) {
    when(users.existsByEmailIgnoreCase("an@example.dev")).thenReturn(true);
    var r = new CreateUserRequest("An", email, "plain-pass-1", null);
    assertThatThrownBy(() -> service.create(r)).isInstanceOf(DuplicateResourceException.class);
}

Stub chỉ khớp với "an@example.dev". Nếu service quên trim() hoặc toLowerCase, stub trả false mặc định và test đỏ: test này thực sự kiểm việc chuẩn hoá.

JUnit 6 trong Spring Boot 4, AssertJ và vài tính năng ít dùng
  • JUnit 6 (đi cùng Spring Boot 4): yêu cầu Java 17+, gom version các module Platform/Jupiter/Vintage về một số, dùng JSpecify cho nullness. Annotation và Assertions của Jupiter không đổi tên. Chỗ cần để ý khi nâng cấp: test JUnit 4 cần Vintage engine riêng (Boot không kèm từ 2.4, JUnit 6 đánh dấu nó deprecated), extension bên thứ ba cũ có thể cần bản mới.
  • AssertJ đi kèm spring-boot-starter-test: assertThat(list).extracting(User::getEmail).containsExactly(...), assertThat(opt).isPresent(), thông báo lỗi rõ hơn assertEquals.
  • @TestInstance(Lifecycle.PER_CLASS): một instance cho cả class, cho phép @BeforeAll không static, nhưng state rò giữa các test.
  • @RepeatedTest(100) để dò test flaky; @Timeout để chặn test treo.
  • assertAll(...) chạy hết các assert rồi báo tất cả cái hỏng, thay vì dừng ở cái đầu.

6. Mockito: mock, stub, spy, fake

Ý chính: test double là vật thay thế dependency. Stub trả dữ liệu dựng sẵn, mock ghi lại lời gọi để verify, spy bọc object thật, fake là cài đặt thật nhưng đơn giản (repository bằng HashMap). Mockito tạo mock/stub/spy; fake thì bạn tự viết.

Loại Mục đích Mockito
Stub cấp input gián tiếp when(repo.exists(..)).thenReturn(true)
Mock kiểm output gián tiếp (tác dụng phụ) verify(repo).save(..), never()
Spy object thật, ghi đè vài method spy(realObject), doReturn(..).when(spy).m()
Fake logic đơn giản nhưng hoạt động tự viết InMemoryUserRepository

Các công cụ dùng nhiều trong lab:

  • thenAnswer(inv -> inv.getArgument(0)): save trả lại chính entity được truyền vào, như JPA.
  • verify(x, never()), verifyNoInteractions(encoder): kiểm điều không được xảy ra (fail sớm thì không hash, không lưu).
  • InOrder: thứ tự có ý nghĩa nghiệp vụ (kiểm trùng → hash → lưu).
  • ArgumentCaptor để lấy object được truyền vào rồi assert nhiều field; argThat(...) cho một điều kiện ngắn ngay trong verify.
ArgumentCaptor<User> saved = ArgumentCaptor.forClass(User.class);
verify(users).save(saved.capture());
assertThat(saved.getValue().getPassword()).isEqualTo("{bcrypt}hash");
assertThat(saved.getValue().getEmail()).isEqualTo("an@example.dev");
Những thứ không nên mock, và inject Clock để test thời gian

Đừng mock:

  • Value object, DTO, record, entity: tạo thật bằng constructor. Mock User để stub getEmail() làm test dài và mong manh.
  • Thứ bạn không sở hữu (RestTemplate, JdbcTemplate, SDK của bên thứ ba): mock nó chỉ kiểm bạn gọi API theo cách bạn tưởng nó hoạt động. Bọc nó sau một interface của bạn (adapter) rồi mock interface đó; còn adapter thì test bằng integration test (WireMock, Testcontainers).
  • Class đang test: nếu phải spy chính nó để stub một method nội bộ, class đang làm quá nhiều việc.
  • Static và final: Mockito 5 mock được (inline mock maker), nhưng cần tới là dấu hiệu thiết kế khó test.

Thời gian: code gọi Instant.now() trực tiếp không test được “token hết hạn sau 7 ngày”. Lab inject Clock:

@Bean Clock clock() { return Clock.systemUTC(); }       // production

// trong test
Clock fixed = Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneOffset.UTC);
var service = new RefreshTokenService(tokens, props, fixed);
// hết hạn? dùng Clock.offset(fixed, Duration.ofDays(8))

Giống vậy cho UUID/SecureRandom: inject một supplier nếu test cần giá trị cố định.

7. Lab: UserServiceTest

Ý chính: UserService.create có ba quyết định: chuẩn hoá email, từ chối email trùng trước khi tốn công hash BCrypt, và chỉ lưu mật khẩu đã hash. Sáu test, mỗi test bắt một cách cài đặt sai cụ thể.

Code được test (Spring Boot 4.0.3, Java 21):

@Transactional
public UserResponse create(CreateUserRequest req) {
    String email = req.email().trim().toLowerCase(Locale.ROOT);
    if (users.existsByEmailIgnoreCase(email)) {
        throw new DuplicateResourceException("User", "email", email);
    }
    User saved = users.save(new User(req.name().trim(), email, passwordEncoder.encode(req.password()), req.gender()));
    return UserResponse.from(saved);
}
Test Bắt được cài đặt sai nào
savesNormalizedEmailAndEncodedPassword lưu mật khẩu thô, quên chuẩn hoá email/name
checksDuplicateBeforeSaving (InOrder) hash trước khi kiểm trùng (tốn ~100 ms BCrypt cho request bị từ chối)
rejectsDuplicateEmailWithoutHashingOrSaving vẫn lưu khi trùng, vẫn gọi encoder
normalizesEmailVariants ×3 kiểm trùng phân biệt hoa thường hoặc khoảng trắng

Chạy mvn test: 6 test này pass trong ~0,25 giây, không khởi động Spring. Test được tạo bằng @Mock cho UserRepository và PasswordEncoder, @InjectMocks UserService. Constructor injection làm việc này đơn giản: không cần Spring, không cần reflection (IoC và DI).

Toàn bộ UserServiceTest
@ExtendWith(MockitoExtension.class)   // strict stubs: an unused when(...) fails the test
class UserServiceTest {
    @Mock UserRepository users;
    @Mock PasswordEncoder encoder;
    @InjectMocks UserService service;

    CreateUserRequest req = new CreateUserRequest(" An ", "An@Example.dev", "plain-pass-1", User.Gender.FEMALE);

    @Nested
    @DisplayName("create()")
    class Create {
        @Test
        void savesNormalizedEmailAndEncodedPassword() {
            when(users.existsByEmailIgnoreCase("an@example.dev")).thenReturn(false);
            when(encoder.encode("plain-pass-1")).thenReturn("{bcrypt}hash");
            when(users.save(any(User.class))).thenAnswer(inv -> inv.getArgument(0));

            var result = service.create(req);

            ArgumentCaptor<User> saved = ArgumentCaptor.forClass(User.class);
            verify(users).save(saved.capture());
            assertThat(saved.getValue().getPassword()).isEqualTo("{bcrypt}hash");
            assertThat(saved.getValue().getEmail()).isEqualTo("an@example.dev");
            assertThat(result.name()).isEqualTo("An");
        }

        @Test
        void checksDuplicateBeforeSaving() {
            when(users.existsByEmailIgnoreCase(any())).thenReturn(false);
            when(encoder.encode(any())).thenReturn("h");
            when(users.save(any())).thenAnswer(inv -> inv.getArgument(0));

            service.create(req);

            InOrder order = inOrder(users, encoder);
            order.verify(users).existsByEmailIgnoreCase("an@example.dev");
            order.verify(encoder).encode("plain-pass-1");
            order.verify(users).save(argThat(u -> !u.getPassword().equals("plain-pass-1")));
        }

        @Test
        void rejectsDuplicateEmailWithoutHashingOrSaving() {
            when(users.existsByEmailIgnoreCase("an@example.dev")).thenReturn(true);

            assertThatThrownBy(() -> service.create(req))
                    .isInstanceOf(DuplicateResourceException.class)
                    .hasMessageContaining("an@example.dev");
            verify(users, never()).save(any());
            verifyNoInteractions(encoder);     // BCrypt is slow: do not pay for it on a rejected request
        }

        @ParameterizedTest
        @ValueSource(strings = {"AN@EXAMPLE.DEV", "  an@example.dev  ", "An@Example.Dev"})
        void normalizesEmailVariants(String email) {
            when(users.existsByEmailIgnoreCase("an@example.dev")).thenReturn(true);
            var r = new CreateUserRequest("An", email, "plain-pass-1", null);
            assertThatThrownBy(() -> service.create(r)).isInstanceOf(DuplicateResourceException.class);
        }
    }
}

Ghi chú: @Nested class không tĩnh nên dùng được field users, req của class ngoài. Surefire báo test này dưới tên nhóm create() (6 test, 0 lỗi).

8. Review test do AI viết, coverage và mutation testing

Ý chính: AI viết test nhanh và đúng cú pháp, nhưng hay viết test gương, chỉ phủ happy path và verify thừa. Review bằng câu hỏi “xoá logic thì test có đỏ không”, và đo sức mạnh test bằng mutation testing thay vì % coverage.

Checklist khi review một bộ unit test:

  • Mỗi test đỏ khi xoá/đảo một dòng logic nào? Không chỉ ra được thì test vô dụng.
  • Mock đúng chỗ: chỉ dependency, không mock class đang test, không mock record/DTO.
  • Nhánh lỗi và early return có never() / verifyNoInteractions chưa?
  • Dữ liệu biến đổi (hash, chuẩn hoá) có được kiểm bằng captor/argThat chưa?
  • Edge case: null, rỗng, khoảng trắng, hoa thường, biên (0, max), thời gian (dùng Clock).
  • Test độc lập: chạy riêng lẻ hay đổi thứ tự vẫn xanh; không phụ thuộc giờ máy, múi giờ, locale.
Mutation testing với PIT

Mutation testing sửa code của bạn một chút (đổi > thành >=, xoá một lời gọi method, trả null), mỗi bản sửa là một mutant, rồi chạy lại test. Test đỏ là mutant bị “giết”; test vẫn xanh là mutant “sống sót”, tức có thay đổi hành vi mà bộ test không nhận ra.

<plugin>
  <groupId>org.pitest</groupId>
  <artifactId>pitest-maven</artifactId>
  <!-- thêm pitest-junit5-plugin làm dependency của plugin -->
  <configuration>
    <targetClasses><param>dev.lab.hr.user.*</param></targetClasses>
  </configuration>
</plugin>

mvn org.pitest:pitest-maven:mutationCoverage sinh báo cáo HTML. Ví dụ với UserService.create: nếu không có normalizesEmailVariants, mutant “bỏ toLowerCase” sẽ sống sót dù line coverage vẫn 100%. PIT chậm (chạy test nhiều lần), nên chạy trên package có logic quan trọng hoặc theo đêm, không chạy mỗi commit. Mình chưa chạy PIT trên lab này; ví dụ mutant ở trên là suy luận từ cách test được viết.

Bài tập

  1. Viết unit test cho RefreshTokenService.rotate trong lab bằng Mockito và một Clock cố định: (a) token hợp lệ thì bị thu hồi và token mới cùng family được lưu; (b) token đã thu hồi dùng lại thì cả family bị thu hồi và ném InvalidRefreshTokenException; (c) token hết hạn đúng tại thời điểm expiresAt thì bị từ chối.
  2. Với mỗi test của bạn, ghi ra dòng code nào bị xoá thì test đỏ.
Lời giải bài 1 (phác thảo)
@ExtendWith(MockitoExtension.class)
class RefreshTokenServiceTest {
    @Mock RefreshTokenRepository tokens;
    Clock clock = Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneOffset.UTC);
    JwtProperties props = new JwtProperties("c2VjcmV0LXNlY3JldC1zZWNyZXQtc2VjcmV0LTMyYnl0ZXMh",
            "test", Duration.ofMinutes(15), Duration.ofDays(7));
    RefreshTokenService service;
    User user = new User("A", "a@x.dev", "h", User.Gender.OTHER);

    @BeforeEach void setUp() { service = new RefreshTokenService(tokens, props, clock); }

    @Test
    void reuseOfRevokedTokenRevokesFamily() {
        var old = new RefreshToken("hash", "fam-1", user, clock.instant().plusSeconds(60));
        old.revoke(clock.instant());
        when(tokens.findByTokenHash(RefreshTokenService.sha256("raw"))).thenReturn(Optional.of(old));

        assertThatThrownBy(() -> service.rotate("raw")).hasMessageContaining("reuse");
        verify(tokens).revokeFamily("fam-1", clock.instant());
        verify(tokens, never()).save(any());
    }

    @Test
    void tokenExpiringExactlyNowIsRejected() {
        var t = new RefreshToken("hash", "fam-1", user, clock.instant());   // expiresAt == now
        when(tokens.findByTokenHash(any())).thenReturn(Optional.of(t));
        assertThatThrownBy(() -> service.rotate("raw")).hasMessageContaining("expired");
    }
}

Test cùng package dev.lab.hr.auth vì constructor của RefreshToken là package-private. Test (b) đỏ nếu xoá revokeFamily; test (c) đỏ nếu đổi !isAfter(now) thành isBefore(now). Lời giải này viết theo code lab nhưng chưa chạy; luồng thật đã được kiểm bằng integration test ở phần 2.

Ghi nhớ

  • Giải thích được vì sao kim tự tháp test là nguyên tắc chi phí và khi nào integration test nên chiếm phần lớn.
  • Phân biệt được quyết định (unit test) và dây nối (slice/integration test) trong một service.
  • Phân biệt được stub, mock, spy, fake và chọn đúng verify, never, InOrder, captor.
  • Biết vì sao strict stubs làm test fail khi có stub thừa, và vì sao không mock value object hay thư viện bên thứ ba.
  • Trả lời được “coverage 90% thì test tốt chưa?” bằng mutation testing.

Câu hỏi phỏng vấn

Junior

Mock và stub khác nhau thế nào?

Stub cấp dữ liệu cho code đang test; mock dùng để kiểm code đã gọi gì (tác dụng phụ).

Trong Mockito cùng một object có thể làm cả hai: when(repo.exists(..)).thenReturn(true) là stub, verify(repo).save(..) là dùng như mock. Quy tắc: query thì stub, command thì verify; đừng verify những lời gọi chỉ để lấy dữ liệu.

AAA là gì?

Arrange – Act – Assert: chuẩn bị dữ liệu và dependency, gọi đúng một hành vi, rồi kiểm kết quả.

Tách ba khúc giúp đọc test như một kịch bản và giữ “một test, một hành vi”. BDD gọi cùng ý đó là Given – When – Then.

Mid

Khi nào nên unit test một method của service, khi nào không?

Unit test khi method có quyết định (nhánh, tính toán, chuẩn hoá, thứ tự); không khi nó chỉ chuyển lời gọi xuống repository.

Với method chỉ nối dây, mock repository chỉ lặp lại cài đặt và vỡ khi refactor. Phần đó kiểm bằng @DataJpaTest hoặc integration test với DB thật. Câu hỏi kiểm tra: xoá logic này thì test có đỏ không.

ArgumentCaptor dùng khi nào?

Khi cần kiểm object được truyền vào dependency, đặc biệt object do chính code tạo ra bên trong (entity được hash mật khẩu rồi mới save).

Captor lấy argument thật rồi assert từng field với thông báo lỗi rõ. argThat gọn hơn cho một điều kiện ngắn, nhất là trong InOrder.

Vì sao Mockito báo UnnecessaryStubbingException và nên xử lý thế nào?

Vì MockitoExtension chạy strict stubs: có when(...) mà code không dùng tới. Thường nên xoá stub đó, không phải tắt kiểm tra.

Stub thừa là dấu hiệu test copy-paste hoặc nhánh code đã đổi. Chỉ dùng lenient() cho stub dùng chung có chủ đích trong @BeforeEach.

Làm sao test code phụ thuộc vào thời gian hiện tại?

Inject java.time.Clock thay vì gọi Instant.now() trực tiếp; test truyền Clock.fixed hoặc Clock.offset.

Như vậy kiểm được biên “hết hạn đúng lúc”, không phải Thread.sleep, không phụ thuộc múi giờ máy CI.

Senior

Team có coverage 85% nhưng bug vẫn lọt. Bạn đánh giá bộ test thế nào?

Coverage chỉ nói code được chạy qua, không nói được kiểm. Tôi đo bằng mutation testing (PIT) trên các package có logic quan trọng và đọc mutant sống sót.

  • Tìm test không assert, test gương, test chỉ happy path.
  • Xem bug lọt nằm ở đâu: logic (thiếu unit test) hay dây nối (thiếu integration test với DB/HTTP thật).
  • Đổi mục tiêu từ % coverage sang: mỗi bug fix có test tái hiện, logic quan trọng có mutation score ổn định.
Bạn có mock RestTemplate hay SDK thanh toán trong unit test không?

Không mock trực tiếp thứ mình không sở hữu. Bọc nó sau một interface (adapter) của mình, mock interface trong unit test, và test adapter bằng integration test với WireMock hoặc sandbox.

Mock thư viện chỉ kiểm rằng code gọi API theo cách mình tưởng; khi thư viện đổi hành vi (timeout, mã lỗi), test vẫn xanh còn production thì hỏng.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
regression /rɪˈɡreʃ.ən/ lỗi cũ quay lại “Every bug fix starts with a failing test so the regression can’t come back.”
test double /test ˈdʌb.əl/ vật thay thế dependency “A fake is a test double with a real but simplified implementation.”
stub /stʌb/ trả dữ liệu dựng sẵn “I stub queries and verify commands.”
spy /spaɪ/ bọc object thật “Needing a spy on the class under test is a design smell.”
argument captor /ˈɑːrɡ.jə.mənt ˈkæp.tɚ/ bắt tham số được truyền “I used an argument captor to check the saved entity had a hashed password.”
strict stubs /strɪkt stʌbz/ chế độ cấm stub thừa “Strict stubs fail the test when a stubbing is never used.”
parameterized test /pəˈræm.ə.tə.raɪzd test/ test nhiều bộ input “One parameterized test covers all the email variants.”
mutation testing /mjuːˈteɪ.ʃən ˈtes.tɪŋ/ đột biến code để đo sức test “Mutation testing tells you whether tests notice a change, coverage doesn’t.”
flaky test /ˈfleɪ.ki test/ test lúc xanh lúc đỏ “Injecting a Clock removed our last flaky test.”
test pyramid /test ˈpɪr.ə.mɪd/ kim tự tháp test “The test pyramid is about cost, not a fixed ratio.”

Ghi chép dựa trên tài liệu khoá học của Hỏi Dân IT, viết lại và bổ sung theo cách hiểu của mình.