Hướng dẫn dùng AI

Nhờ AI viết test tự động mà test vẫn bắt được lỗi

Nhờ AI viết test cho một hàm là việc rất tiện: vài giây đã có cả chục test, chạy qua hết, độ phủ trông đẹp. Nhưng một bộ test qua hết chưa chắc đã kiểm được gì. Nếu test chỉ thử những giá trị "đẹp", một lỗi nhỏ ở đúng chỗ mốc sẽ lọt qua mà không test nào trượt. Bài này chỉ cách đo chất lượng bộ test do AI viết bằng một kỹ thuật đơn giản: cố ý cài lỗi vào hàm rồi xem test có bắt được không.

Ý chính
  • Test do AI viết có thể sai: nghiên cứu năm 2023 về ChatGPT ghi nhận test bị lỗi biên dịch và chạy hỏng. Luôn chạy test trước khi tin.
  • Test qua hết và độ phủ cao chưa nói lên test có bắt được lỗi hay không.
  • Kiểm thử đột biến: tạo các bản lỗi nhỏ của hàm; test tốt phải trượt trên các bản đó. Bản lỗi nào test vẫn qua chỉ ra chỗ thiếu ca thử.
  • Nhờ AI viết thêm ca thử đúng tại các mốc, hai bên mốc, và giá trị ngoài khoảng cho phép.

Bài dùng Python thuần cho phần đo; khi làm thật, bạn sẽ dùng pytest và có thể dùng công cụ mutmut. Các nguồn gồm nghiên cứu của Yuan và cộng sự về việc ChatGPT sinh unit test, tài liệu mutmut, tài liệu pytest về tham số hóa và trang Coverage.py, đọc ngày 11/11/2026.

AI viết test giỏi tới đâu

Nghiên cứu của Yuan và cộng sự, được giới thiệu là nghiên cứu thực nghiệm đầu tiên đánh giá khả năng sinh unit test của ChatGPT, cho kết quả hai mặt. Mặt tốt: những test chạy qua được thì đạt độ phủ, độ dễ đọc tương đương test do người viết, có lúc còn được lập trình viên ưa hơn. Mặt chưa tốt: nhiều test bị lỗi biên dịch hoặc chạy hỏng. Nhóm tác giả kết luận việc dùng ChatGPT sinh test rất hứa hẹn nếu cải thiện được độ đúng của test, và đề xuất một công cụ lặp đi lặp lại việc sửa test dựa trên thông báo lỗi.

Bài học thực tế: đừng chép test AI viết vào dự án mà không chạy. Nhưng chạy qua hết cũng chưa đủ. Có một kiểu yếu khó nhận ra hơn: test đúng nhưng không kiểm được gì quan trọng.

Test qua hết chưa phải test tốt

Thử với hàm xếp loại học lực: từ 8 điểm là Giỏi, từ 6,5 là Khá, từ 5 là Trung bình, dưới 5 là Yếu, và điểm ngoài khoảng 0 tới 10 thì báo lỗi. Một bộ test điển hình AI có thể đưa ra gồm bốn ca: 9,5 là Giỏi, 7 là Khá, 5,5 là Trung bình, 3 là Yếu. Bốn test này đúng, qua hết. Nhưng nếu ai đó lỡ tay đổi dấu lớn hơn hoặc bằng thành lớn hơn, học sinh được đúng 8 điểm sẽ bị xếp Khá, và cả bốn test vẫn qua. Lỗi ở mốc là loại lỗi hay gặp nhất trong code thật, và cũng là loại mà các giá trị "đẹp" không bao giờ chạm tới.

Độ phủ dòng, thứ mà các công cụ như Coverage.py đo, cho biết những dòng nào được chạy qua khi chạy test. Nó hữu ích để tìm đoạn code chưa có test nào chạm tới. Nhưng một dòng được chạy qua không có nghĩa là kết quả của nó được kiểm đúng. Bộ bốn test ở trên chạy qua gần hết các dòng của hàm, mà không phát hiện được lỗi ở mốc nào.

Kiểm thử đột biến

Ý tưởng rất đơn giản. Tạo ra những bản sao của hàm, mỗi bản có một thay đổi nhỏ giống lỗi thật: đổi phép so sánh, đổi một hằng số, bỏ một dòng kiểm. Mỗi bản như vậy gọi là một đột biến. Chạy bộ test trên từng đột biến. Nếu ít nhất một test trượt, đột biến bị "diệt": bộ test đã bắt được lỗi đó. Nếu mọi test vẫn qua, đột biến "còn sống": có một lỗi mà bộ test của bạn không nhìn thấy, và đó chính là chỗ cần thêm ca thử.

Trong Python, công cụ mutmut làm việc này tự động: tự sinh đột biến từ code của bạn, chạy test, và cho xem các đột biến còn sống. Tài liệu mutmut lưu ý công cụ cần hệ điều hành hỗ trợ fork, nên trên Windows phải chạy trong WSL. Chương trình trong bài làm thủ công với bốn đột biến chọn sẵn, để thấy rõ cơ chế.

Test có bắt được lỗi không? Cài lỗi cố ý rồi xem test có trượt 1. AI viết testBộ yếu: 4 testtoàn điểm đẹp 2. Đo độ phủPhủ 8/9 dòngtrông ổn 3. Cài đột biếnDiệt 0/4lỗi lọt hết 4. Thêm ca mốcBộ mạnh: 9 testdiệt 4/4 Hai bộ test trong ví dụ là giả lập do bài tự viết
Test có bắt được lỗi không? 1. AI viết testBộ yếu: 4 testtoàn điểm đẹp 2. Đo độ phủPhủ 8/9 dòngtrông ổn 3. Cài đột biếnDiệt 0/4lỗi lọt hết 4. Thêm ca mốcBộ mạnh: 9 testdiệt 4/4 Hai bộ test trong ví dụ là giả lập do bài tự viết
Hình 1. Test có bắt được lỗi không, cài lỗi cố ý rồi xem test có trượt: (1) AI viết bộ test yếu gồm 4 test toàn điểm đẹp; (2) đo độ phủ được 8 trên 9 dòng, trông ổn; (3) cài đột biến thì bộ yếu diệt 0 trên 4, mọi lỗi đều lọt; (4) thêm ca tại các mốc thành bộ mạnh 9 test, diệt 4 trên 4. Hai bộ test trong ví dụ là giả lập do bài tự viết.

Ví dụ bằng Python

Chương trình mẫu gồm hàm xep_loai, bốn đột biến, và hai bộ test giả lập do bài tự viết theo kiểu AI hay đưa ra. Hàm do_bo_test chạy bộ test trên hàm gốc trước; nếu bộ test trượt ngay trên hàm gốc thì bộ đó sai và không được tính điểm. Sau đó nó chạy trên từng đột biến và liệt kê đột biến còn sống. Hàm do_phu đo độ phủ dòng bằng cơ chế theo dõi có sẵn của Python, để so với tỷ lệ diệt đột biến.

"""Nhờ AI viết test rồi đo xem test có bắt được lỗi không, bằng cách tạo "đột biến": các bản lỗi cố ý của hàm.

- xep_loai: hàm cần kiểm (xếp loại học lực theo điểm trung bình, bài tự đặt mốc).
- DOT_BIEN: các bản sửa sai một chỗ nhỏ (đổi >= thành >, đổi mốc, quên kiểm điểm ngoài 0-10).
- BO_TEST_YEU / BO_TEST_MANH: hai bộ test GIẢ LẬP, do bài tự viết theo kiểu AI hay đưa ra: bộ yếu chỉ thử các điểm "đẹp",
  bộ mạnh thử đúng các mốc và giá trị ngoài khoảng.
- do_bo_test: chạy mỗi bộ test trên hàm gốc (phải qua hết) và trên từng đột biến (đột biến "bị diệt" nếu có test trượt).
- do_phu: tỷ lệ dòng của xep_loai được chạy qua (độ phủ dòng), đo bằng sys.settrace, để so với tỷ lệ diệt đột biến.
"""
import dis
import sys


def xep_loai(diem):
    if not 0 <= diem <= 10:
        raise ValueError("điểm phải trong 0-10")
    if diem >= 8:
        return "Giỏi"
    if diem >= 6.5:
        return "Khá"
    if diem >= 5:
        return "Trung bình"
    return "Yếu"


def _dot_bien(moc_gioi=8, moc_kha=6.5, so_sanh_ngat=False, kiem_khoang=True):
    def ham(diem):
        if kiem_khoang and not 0 <= diem <= 10:
            raise ValueError("điểm phải trong 0-10")
        lon = (lambda a, b: a > b) if so_sanh_ngat else (lambda a, b: a >= b)
        if lon(diem, moc_gioi):
            return "Giỏi"
        if lon(diem, moc_kha):
            return "Khá"
        if lon(diem, 5):
            return "Trung bình"
        return "Yếu"
    return ham


DOT_BIEN = {
    "đổi >= thành >": _dot_bien(so_sanh_ngat=True),
    "mốc Giỏi 8 thành 8.5": _dot_bien(moc_gioi=8.5),
    "mốc Khá 6.5 thành 6": _dot_bien(moc_kha=6),
    "quên kiểm điểm ngoài 0-10": _dot_bien(kiem_khoang=False),
}


def _phai_loi(ham, diem):
    try:
        ham(diem)
    except ValueError:
        return True
    return False


BO_TEST_YEU = [
    lambda f: f(9.5) == "Giỏi",
    lambda f: f(7) == "Khá",
    lambda f: f(5.5) == "Trung bình",
    lambda f: f(3) == "Yếu",
]
BO_TEST_MANH = BO_TEST_YEU + [
    lambda f: f(8) == "Giỏi" and f(7.9) == "Khá",
    lambda f: f(6.5) == "Khá" and f(6.4) == "Trung bình",
    lambda f: f(5) == "Trung bình" and f(4.9) == "Yếu",
    lambda f: f(0) == "Yếu" and f(10) == "Giỏi",
    lambda f: _phai_loi(f, -1) and _phai_loi(f, 10.5),
]


def _qua(bo_test, ham):
    for t in bo_test:
        try:
            if not t(ham):
                return False
        except Exception:  # noqa: BLE001  (test làm hàm báo lỗi lạ cũng tính là trượt)
            return False
    return True


def do_phu(bo_test):
    ma = xep_loai.__code__
    can = {d for _, d in dis.findlinestarts(ma) if d and d > ma.co_firstlineno}
    da_chay = set()

    def theo_doi(khung, su_kien, _):
        if khung.f_code is ma and su_kien == "line":
            da_chay.add(khung.f_lineno)
        return theo_doi

    sys.settrace(theo_doi)
    try:
        _qua(bo_test, xep_loai)
    finally:
        sys.settrace(None)
    return len(da_chay & can), len(can)


def do_bo_test(bo_test):
    if not _qua(bo_test, xep_loai):
        return None, []
    con_song = [ten for ten, ham in DOT_BIEN.items() if _qua(bo_test, ham)]
    return len(DOT_BIEN) - len(con_song), con_song


def chay_thu():
    dong = []
    for ten, bo in (("Bộ test yếu", BO_TEST_YEU), ("Bộ test mạnh", BO_TEST_MANH)):
        diet, con_song = do_bo_test(bo)
        phu, tong = do_phu(bo)
        dong.append(f"{ten} ({len(bo)} test): qua hàm gốc, phủ {phu}/{tong} dòng, diệt {diet}/{len(DOT_BIEN)} đột biến")
        dong += [f"  - còn sống: {t}" for t in con_song]
    print("\n".join(dong))
    return dong


if __name__ == "__main__":
    chay_thu()

Bộ test yếu bốn ca qua hàm gốc, phủ 8 trên 9 dòng, nhưng diệt 0 trên 4 đột biến: đổi dấu so sánh, dời mốc Giỏi lên 8,5, hạ mốc Khá xuống 6, và bỏ dòng kiểm điểm ngoài khoảng, tất cả đều lọt. Bộ test mạnh thêm năm ca: đúng mốc và ngay dưới mốc ở 8, 6,5 và 5; hai đầu 0 và 10; và hai giá trị ngoài khoảng phải báo lỗi. Bộ này phủ đủ 9 dòng và diệt cả 4 đột biến. Khác biệt về độ phủ chỉ là một dòng, nhưng khác biệt về khả năng bắt lỗi là từ không thành tất cả.

Nhờ AI viết test tốt hơn

Khi nhờ AI viết test, hãy nói rõ những gì cần thử: mỗi mốc trong điều kiện, giá trị ngay trên và ngay dưới mốc, hai đầu của khoảng hợp lệ, giá trị ngoài khoảng, dữ liệu rỗng, kiểu dữ liệu sai. Yêu cầu viết bằng pytest với tham số hóa, để mỗi ca là một dòng trong bảng, dễ đọc và dễ thêm. Tài liệu pytest mô tả cách đánh dấu một hàm test với danh sách tham số để chạy cùng một test cho nhiều bộ đầu vào và kết quả mong đợi.

Sau đó, đưa cho AI danh sách đột biến còn sống và hỏi: cần thêm ca thử nào để bắt được đột biến này. Đây là kiểu câu hỏi cụ thể mà mô hình trả lời tốt, và mỗi ca thêm vào đều có lý do rõ. Kết quả mong đợi của mỗi ca phải lấy từ đặc tả, không lấy từ việc chạy code hiện tại: nếu code đang sai, test sinh ra từ code sẽ khóa luôn cái sai đó lại. Với việc chuyển code giữa hai ngôn ngữ, đáp án lấy từ bản gốc như bài chuyển code bằng AI đã làm.

Một vòng làm việc mẫu cho một hàm mới trông như sau. Viết đặc tả ngắn bằng lời: đầu vào hợp lệ là gì, kết quả ra sao ở từng trường hợp, khi nào báo lỗi. Đưa đặc tả và code cho AI, nhờ viết bộ test pytest có tham số hóa. Chạy test trên code; test nào trượt thì đọc lại đặc tả để biết lỗi nằm ở test hay ở code. Khi bộ test đã qua, chạy kiểm thử đột biến, gửi danh sách đột biến còn sống cho AI để xin thêm ca thử, chạy lại. Dừng khi các đột biến còn sống chỉ là những thay đổi không làm đổi hành vi, ví dụ đổi tên một biến nội bộ. Với dữ liệu thử cần nhiều dòng, có thể nhờ AI sinh dữ liệu mẫu rồi soát, như bài sinh dữ liệu mẫu bằng AI hướng dẫn.

Cuối cùng, cho bộ test chạy tự động mỗi lần đẩy code, như bài GitHub Actions cho dự án AI hướng dẫn, và chạy kiểm thử đột biến định kỳ cho những mô-đun quan trọng nhất, vì nó tốn thời gian hơn chạy test thường nhiều lần.

Cẩn thận
  • Chép test AI viết vào dự án mà không chạy.
  • Lấy độ phủ cao làm bằng chứng test tốt.
  • Chỉ thử giá trị đẹp, bỏ qua mốc và giá trị ngoài khoảng.
  • Lấy kết quả mong đợi từ việc chạy code đang có thay vì từ đặc tả.
  • Để AI sửa test cho qua thay vì sửa code khi test trượt đúng.

Câu hỏi thường gặp

Độ phủ bao nhiêu là đủ?

Không có con số chung. Độ phủ cho biết chỗ chưa thử, tỷ lệ diệt đột biến cho biết test có bắt lỗi.

Kiểm thử đột biến có chậm không?

Có, vì phải chạy bộ test nhiều lần. Nên chạy định kỳ cho phần quan trọng.

Test trượt thì sửa test hay sửa code?

Đọc đặc tả trước. Test đúng đặc tả mà trượt thì sửa code.

Khác gì bài viết test cho ứng dụng AI?

Bài kia nói cách thử ứng dụng có gọi mô hình; bài này nói cách đo test do AI viết.

Học tiếp

Nếu bạn muốn học Python và AI bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.

Muốn học bài bản cùng giảng viên?

Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.

Xem Khóa AI

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483