# Khóa học T5Edu

Danh sách các khóa học Tester công khai đang mở trên T5Edu.

- Canonical: https://t5edu.site/courses
- Markdown: https://t5edu.site/courses.md
- Cập nhật: 2026-08-14
- Loại nội dung: courses-index

## Danh sách khóa học

### Khóa học: Git và Github

- Giá: Miễn phí
- Chương: 2
- Bài học đã xuất bản: 24
- HTML: https://t5edu.site/courses/git-va-github
- Markdown: https://t5edu.site/courses/git-va-github.md

````markdown
### Mô tả khóa học: Git và Github

## Giới thiệu

Git không chỉ giúp lưu lại mã nguồn, mà còn là nền tảng để SDET kiểm soát thay đổi, cộng tác minh bạch và bảo vệ chất lượng dự án trong từng lần phát hành. Khóa học **Git và Github** được xây dựng để bạn hiểu bản chất phía sau mỗi thao tác, từ đó làm việc chủ động với lịch sử mã nguồn thay vì chỉ ghi nhớ câu lệnh. Bạn sẽ từng bước hình thành quy trình Git an toàn, rõ ràng và phù hợp với thực tế phát triển phần mềm hiện đại.

## Bạn sẽ học được gì?
- Hiểu cách Git lưu trữ dữ liệu theo **nội dung** và vận hành lịch sử dự án qua các object như **Blob, Tree, Commit, Tag**.
- Thực hành thành thạo quy trình làm việc cốt lõi: theo dõi thay đổi, staging, commit, xem lịch sử, so sánh khác biệt và tạm cất công việc bằng **stash**.
- Tự thiết lập môi trường Git cá nhân nhất quán với **branch mặc định**, pull rebase, line endings, alias và `.gitignore` phù hợp cho dự án kiểm thử.
- Làm việc tự tin với **branch, merge, rebase, conflict** và lựa chọn cách tích hợp mã nguồn phù hợp với từng tình huống.
- Cộng tác chuyên nghiệp trên **GitHub** thông qua Pull Request, review, branch protection, release tag, hotfix và quản lý remote an toàn.

## Đối tượng phù hợp
- Người mới bắt đầu học Git hoặc đã sử dụng Git theo thói quen nhưng chưa hiểu rõ cơ chế hoạt động bên trong.
- QA, Tester, SDET và Automation Tester cần quản lý mã kiểm thử chuyên nghiệp trong môi trường dự án thực tế.
- Lập trình viên muốn chuẩn hóa quy trình Git cá nhân, giảm rủi ro khi cộng tác và xử lý thay đổi hiệu quả hơn.

---

## Nội dung khoá học

### Chương 1: Kiến thức cơ bản, Object và cấu hình Git cho SDET

Chương học này giúp bạn xây dựng nền móng để dùng Git theo hướng **hiểu bản chất** thay vì thao tác theo mẫu có sẵn. Bạn sẽ khám phá mô hình Git phân tán, cách repository lưu trữ nội dung qua **Blob, Tree, Commit và Tag**, từ đó nhìn rõ mối liên hệ giữa thay đổi trong file, snapshot và lịch sử dự án. Song song với kiến thức nền tảng, bạn trực tiếp rèn luyện các thao tác thiết yếu như theo dõi trạng thái, staging, commit, đọc lịch sử, so sánh khác biệt và tạm cất công việc. Sau chương này, bạn còn có thể tự thiết lập một môi trường Git phù hợp cho công việc SDET với cấu hình global, alias quan sát repository, quy tắc line endings và `.gitignore` cho các công nghệ kiểm thử phổ biến; đặc biệt là hình thành tư duy **bảo vệ secret** và biết cách ứng phó khi file `.env` bị commit nhầm.

### Chương 2: Branching, Merging, Rebase và cộng tác trên GitHub

Từ nền tảng về lịch sử và cấu hình Git ở chương trước, bạn sẽ tiếp tục học cách biến những thay đổi cá nhân thành một quy trình cộng tác an toàn trong dự án. Chương học tập trung vào vòng đời của **feature branch**, cách lựa chọn giữa **merge** và **rebase**, cũng như phương pháp xử lý **merge conflict** một cách bình tĩnh, có kiểm soát thay vì thử lại ngẫu nhiên. Bạn cũng sẽ thực hành quy trình làm việc trên **GitHub** với Pull Request, review, branch protection, kiểm tra CI và checkout Pull Request tại local để kiểm thử. Khi hoàn thành chương này, bạn có thể tự tin phối hợp cùng đội nhóm, giữ lịch sử repository rõ ràng, quản lý release và hotfix bằng tag hoặc cherry-pick, đồng thời duy trì một quy trình tích hợp mã nguồn phù hợp với tiêu chuẩn chất lượng của dự án.

> Các bài học về CICD, Github Actions, các câu hỏi phỏng vấn về GIT dành cho QA engineer đang hoàn thiện...

### Nội dung học: Git và Github

#### Chương 1: Kiến thức cơ bản, Object và cấu hình Git cho SDET

- Bài 0: Git phân tán, repository hoàn chỉnh và lưu trữ theo nội dung (THEORY)
- Bài 1: Bốn Git object cốt lõi: Blob, Tree, Commit và Tag (THEORY)
- Bài 2: Phân biệt annotated tag và lightweight tag (THEORY)
- Bài 3: Khám phá quan hệ giữa nội dung, snapshot và lịch sử commit (EXERCISE)
- Bài 4: Các lệnh Git thiết yếu trong công việc SDET (THEORY)
- Bài 5: Thực hành init, status, add, commit, log, diff và stash (EXERCISE)
- Bài 6: Cấu hình danh tính và thiết lập Git global (THEORY)
- Bài 7: Thiết lập branch mặc định, pull rebase và line endings (EXERCISE)
- Bài 8: Tạo alias để xem lịch sử và trạng thái repository (EXERCISE)
- Bài 9: Bảo vệ secret và xử lý khi file .env bị commit (THEORY)
- Bài 10: Xây dựng .gitignore cho Node, Playwright, Java, Maven, IDE và hệ điều hành (EXERCISE)
- Bài 11: Kiểm tra kiến thức về Git object, lệnh và cấu hình dự án (QUIZ)

#### Chương 2: Branching, Merging, Rebase và cộng tác trên GitHub

- Bài 1: Branch trong Git và các chiến lược rẽ nhánh dành cho SDET (THEORY)
- Bài 2: Thực hành vòng đời feature branch: tạo, chuyển, liệt kê, push và xóa branch (EXERCISE)
- Bài 3: Merge và rebase: khác biệt, rủi ro và tiêu chí lựa chọn (THEORY)
- Bài 4: Thực hành tích hợp feature branch bằng merge và rebase (EXERCISE)
- Bài 5: Giải quyết merge conflict bằng thao tác thủ công và mergetool (EXERCISE)
- Bài 6: Cộng tác trên GitHub với Pull Request và quy trình review (THEORY)
- Bài 7: Thiết lập branch protection cho main (EXERCISE)
- Bài 8: Làm việc với remote bằng fetch, prune và pull rebase (EXERCISE)
- Bài 9: Checkout Pull Request ở local để kiểm thử (EXERCISE)
- Bài 10: Quản lý release và hotfix bằng tag, cherry-pick và upstream (THEORY)
- Bài 11: Thực hành tạo release tag và cherry-pick bản sửa lỗi có xung đột (EXERCISE)
- Bài 12: Đánh giá lựa chọn chiến lược branching và cộng tác an toàn (QUIZ)

````

---

### Khóa học: Java cho QA engineer

- Giá: 29.000đ
- Chương: 4
- Bài học đã xuất bản: 81
- HTML: https://t5edu.site/courses/java-cho-qa-engineer
- Markdown: https://t5edu.site/courses/java-cho-qa-engineer.md

````markdown
### Mô tả khóa học: Java cho QA engineer

## Giới thiệu

Khoá học **Java cho QA engineer** được xây dựng dành riêng cho QA Manual muốn chuyển từ việc kiểm thử thủ công sang tư duy lập trình và Automation Testing một cách bài bản. Thay vì học Java qua các ví dụ xa rời thực tế, bạn sẽ tiếp cận kiến thức thông qua những bài toán quen thuộc như xử lý dữ liệu từ UI, đánh giá kết quả test, quản lý cấu hình và tổ chức code cho framework kiểm thử. Đây là nền tảng quan trọng để bạn tự tin đọc hiểu code, học Selenium/Appium và tiến gần hơn đến vai trò QA Automation hoặc SDET.

## Bạn sẽ học được gì?

- Hiểu rõ cách **Java hỗ trợ QA Automation và SDET**, từ đó xác định vai trò của lập trình trong lộ trình phát triển nghề nghiệp kiểm thử.
- Tự viết, chạy và tổ chức chương trình Java với **biến, kiểu dữ liệu, String, hằng số, ép kiểu và toán tử** để xử lý dữ liệu kiểm thử.
- Xây dựng logic đánh giá **pass/fail**, xử lý điều kiện, chạy theo lô, retry và chuẩn hóa dữ liệu UI bằng **câu lệnh điều kiện, vòng lặp, mảng và chuỗi**.
- Áp dụng **OOP, Collection, Exception và Interface** để thiết kế các thành phần kiểm thử có khả năng tái sử dụng, mở rộng và bảo trì.
- Sẵn sàng đọc hiểu cấu trúc code trong dự án thực tế và tiếp cận các framework Automation Testing với tư duy rõ ràng hơn.

## Đối tượng phù hợp

- QA Manual muốn xây dựng nền tảng Java trước khi học Selenium, Appium hoặc các công cụ Automation Testing.
- Người mới học Java nhưng mong muốn ứng dụng kiến thức trực tiếp vào các tình huống kiểm thử phần mềm.
- Junior QA/QC cần nâng cao kỹ năng xử lý dữ liệu, đọc hiểu code và phối hợp hiệu quả hơn với đội ngũ phát triển.

---

## Nội dung khoá học

### Chương 1: Nền tảng Java: Chương trình đầu tiên, Kiểu dữ liệu và Toán tử

Chương học mở đầu giúp bạn nhìn Java từ đúng góc độ của một QA engineer: một công cụ để chuyển các quy tắc kiểm thử thành logic có thể thực thi. Bạn sẽ từng bước tạo chương trình đầu tiên, hiểu cấu trúc class, viết **console log**, **comment** và **JavaDoc** rõ ràng để code dễ đọc, dễ bảo trì. Trên nền tảng đó, bạn sẽ làm chủ **biến, kiểu dữ liệu, String, hằng số, ép kiểu và chuyển đổi dữ liệu** thường gặp khi lấy thông tin từ giao diện. Các **toán tử số học, so sánh, logic và ba ngôi** sẽ được gắn với những tình huống thực tế như validation, tính tỷ lệ pass và xác định trạng thái của test suite.

### Chương 2: Luồng điều khiển, Vòng lặp, Mảng và Chuỗi trong Java

Từ khả năng xử lý dữ liệu và viết các phép so sánh ở chương đầu, bạn sẽ tiếp tục biến chúng thành những luồng kiểm thử hoàn chỉnh. Chương này giúp bạn sử dụng **if-else** và **switch** để phân nhánh theo trạng thái test, quyền người dùng hoặc cấu hình trình duyệt; đồng thời vận dụng **vòng lặp** để chạy test theo lô, xử lý retry và bỏ qua các kịch bản không cần thực thi. Bạn cũng sẽ biết cách quản lý test data có cấu trúc bằng **mảng**, mảng nhiều chiều và các tiện ích xử lý mảng. Với **String** và **StringBuilder**, bạn có thể chuẩn hóa nội dung UI, so sánh văn bản đúng cách và tạo báo cáo kết quả rõ ràng, nhất quán hơn.

### Chương 3: Lập trình hướng đối tượng trong Java cho QA Automation

Khi đã có thể điều khiển luồng xử lý và làm việc với dữ liệu, bạn sẽ học cách tổ chức code theo tư duy **lập trình hướng đối tượng (OOP)** — nền tảng của hầu hết framework QA Automation. Chương học giúp bạn mô hình hóa các đối tượng quen thuộc như test case, trình duyệt và phần tử giao diện thông qua **class, object, thuộc tính, phương thức và constructor**. Bạn sẽ hiểu sâu hơn cách áp dụng **đóng gói, kế thừa, đa hình, nạp chồng và ghi đè phương thức** để giảm lặp code, bảo vệ dữ liệu và mở rộng chức năng một cách an toàn. Sau chương này, bạn sẽ có nền tảng vững vàng hơn để đọc hiểu cấu trúc framework và thiết kế các thành phần automation có khả năng tái sử dụng.

### Chương 4: Collection, Xử lý Exception và Interface cho QA Automation

Khép lại lộ trình nền tảng Java, chương này đưa bạn đến gần hơn với cách một framework Automation thực tế quản lý dữ liệu, xử lý sự cố và kết nối các thành phần với nhau. Bạn sẽ lựa chọn và sử dụng **ArrayList, HashMap, HashSet** để quản lý test data, cấu hình môi trường, danh sách trình duyệt và kết quả kiểm thử linh hoạt hơn so với mảng cố định. Bên cạnh đó, kỹ năng xử lý lỗi bằng **try-catch-finally**, **throw**, **throws** và **custom exception** giúp bạn xây dựng cơ chế phản hồi phù hợp cho lỗi runtime, flaky test hoặc lỗi nghiệp vụ. Cuối cùng, với **interface** và tư duy lập trình theo hợp đồng hành vi, bạn sẽ hiểu cách thiết kế các thành phần đa trình duyệt, phần tử UI và khả năng dùng lại trong QA Automation một cách rõ ràng, dễ mở rộng.

### Nội dung học: Java cho QA engineer

#### Chương 1: Nền tảng Java: Chương trình đầu tiên, Kiểu dữ liệu và Toán tử

- Bài 1: Vai trò của Java trong QA và SDET (THEORY)
- Bài 2: Chuẩn bị môi trường và phân tích chương trình Hello World (THEORY)
- Bài 3: Thực hành tạo và chạy chương trình Java đầu tiên (EXERCISE)
- Bài 4: In dữ liệu với print và println (THEORY)
- Bài 5: Thực hành định dạng console log cho kịch bản kiểm thử (EXERCISE)
- Bài 6: Comment, JavaDoc và quy tắc tổ chức class Java (THEORY)
- Bài 7: Kiểu dữ liệu nguyên thủy và kiểu tham chiếu (THEORY)
- Bài 8: Khai báo, khởi tạo và đặt tên biến trong code QA (THEORY)
- Bài 9: Thực hành quản lý dữ liệu trình duyệt và kết quả kiểm thử (EXERCISE)
- Bài 10: Ép kiểu và chuyển đổi dữ liệu String (THEORY)
- Bài 11: Thực hành chuyển đổi dữ liệu UI phục vụ assertion (EXERCISE)
- Bài 12: Khai báo hằng số cấu hình bằng từ khóa final (THEORY)
- Bài 13: Toán tử số học, tăng giảm và phép chia trong Java (THEORY)
- Bài 14: Toán tử gán và tích lũy kết quả kiểm thử (THEORY)
- Bài 15: Thực hành tính tỷ lệ pass và thời gian chạy test suite (EXERCISE)
- Bài 16: Toán tử so sánh trong assertion và validation (THEORY)
- Bài 17: Toán tử logic và cơ chế đánh giá ngắn mạch (THEORY)
- Bài 18: Toán tử ba ngôi để xác định trạng thái kiểm thử (THEORY)
- Bài 19: Thực hành xây dựng logic đánh giá test suite (EXERCISE)
- Bài 20: Kiểm tra kiến thức về kiểu dữ liệu, biến và toán tử (QUIZ)

#### Chương 2: Luồng điều khiển, Vòng lặp, Mảng và Chuỗi trong Java

- Bài 1: Câu lệnh điều kiện và ứng dụng trong logic kiểm thử (THEORY)
- Bài 2: If-Else, thứ tự đánh giá và các nhánh kết quả loại trừ (THEORY)
- Bài 3: Thực hành phân loại kết quả test theo tỷ lệ pass (EXERCISE)
- Bài 4: Switch, break và lựa chọn trình duyệt từ cấu hình (THEORY)
- Bài 5: If lồng nhau và cách tránh logic lồng quá sâu (THEORY)
- Bài 6: Thực hành kiểm tra đăng nhập, quyền hạn và vai trò người dùng (EXERCISE)
- Bài 7: Vòng lặp for và lỗi sai lệch chỉ số (THEORY)
- Bài 8: Vòng lặp while và cơ chế retry trong kiểm thử (THEORY)
- Bài 9: Vòng lặp do-while cho tác vụ phải thực thi ít nhất một lần (THEORY)
- Bài 10: Điều khiển vòng lặp bằng break và continue (THEORY)
- Bài 11: Thực hành chạy test theo lô, retry và bỏ qua test bị vô hiệu hóa (EXERCISE)
- Bài 12: Khai báo, khởi tạo và truy cập phần tử mảng (THEORY)
- Bài 13: Duyệt mảng bằng for và enhanced for loop (THEORY)
- Bài 14: Thực hành quản lý danh sách trình duyệt và trạng thái test (EXERCISE)
- Bài 15: Mảng nhiều chiều cho dữ liệu kiểm thử dạng bảng (THEORY)
- Bài 16: Thao tác mảng với java.util.Arrays (THEORY)
- Bài 17: Thực hành tổng hợp kết quả của nhiều test suite bằng mảng hai chiều (EXERCISE)
- Bài 18: String, String Pool và tính bất biến của chuỗi (THEORY)
- Bài 19: Các phương thức xử lý chuỗi thường dùng trong QA (THEORY)
- Bài 20: So sánh chuỗi đúng cách với equals và equalsIgnoreCase (THEORY)
- Bài 21: StringBuilder và tối ưu thao tác nối chuỗi (THEORY)
- Bài 22: Thực hành chuẩn hóa, tách và xác minh nội dung văn bản từ UI (EXERCISE)
- Bài 23: Thực hành tạo báo cáo kết quả test bằng StringBuilder (EXERCISE)
- Bài 24: Ôn tập luồng điều khiển, vòng lặp, mảng và chuỗi (QUIZ)

#### Chương 3: Lập trình hướng đối tượng trong Java cho QA Automation

- Bài 1: OOP và vai trò trong framework QA Automation (THEORY)
- Bài 2: Class, object, thuộc tính, phương thức và từ khóa this (THEORY)
- Bài 3: Xây dựng class TestCase và theo dõi trạng thái độc lập của từng test (EXERCISE)
- Bài 4: Constructor và nạp chồng constructor để khởi tạo cấu hình trình duyệt (THEORY)
- Bài 5: Thực hành thiết kế class Browser với nhiều cách khởi tạo (EXERCISE)
- Bài 6: Nạp chồng phương thức và đa hình tại thời điểm biên dịch (THEORY)
- Bài 7: Thành viên static và rủi ro nhiễm dữ liệu chéo giữa các test (THEORY)
- Bài 8: Thực hành quản lý cấu hình và bộ đếm test bằng thành viên static (EXERCISE)
- Bài 9: Đóng gói và phạm vi truy cập trong Java (THEORY)
- Bài 10: Getter, setter và validation dữ liệu có kiểm soát (THEORY)
- Bài 11: Thực hành đóng gói dữ liệu User và bảo vệ thông tin nhạy cảm (EXERCISE)
- Bài 12: Kế thừa, quan hệ IS-A, từ khóa extends và super (THEORY)
- Bài 13: Thực hành xây dựng WebElement, Button và TextBox có khả năng tái sử dụng (EXERCISE)
- Bài 14: Ghi đè phương thức với @Override và mở rộng hành vi class cha (THEORY)
- Bài 15: Thực hành xây dựng TestCase và WebTest bằng method overriding (EXERCISE)
- Bài 16: Đa hình tại thời điểm thực thi trong báo cáo và trình duyệt (THEORY)
- Bài 17: Thực hành thiết kế TestRunner chạy nhiều loại Browser bằng đa hình (EXERCISE)
- Bài 18: Kiểm tra kiến thức OOP ứng dụng trong QA Automation (QUIZ)

#### Chương 4: Collection, Xử lý Exception và Interface cho QA Automation

- Bài 1: Tổng quan Collections Framework và cách chọn Collection cho dữ liệu kiểm thử (THEORY)
- Bài 2: ArrayList: Quản lý danh sách test data có kích thước động (THEORY)
- Bài 3: Thực hành ArrayList: Thêm, truy xuất, xóa và duyệt danh sách trình duyệt (EXERCISE)
- Bài 4: HashMap: Lưu trữ cấu hình và test data theo cặp key-value (THEORY)
- Bài 5: Thực hành HashMap: Quản lý thông tin đăng nhập và môi trường kiểm thử (EXERCISE)
- Bài 6: HashSet: Quản lý ID và kết quả kiểm thử không trùng lặp (THEORY)
- Bài 7: Thực hành kết hợp HashMap và ArrayList để thống kê kết quả test (EXERCISE)
- Bài 8: Xử lý lỗi runtime với try-catch-finally (THEORY)
- Bài 9: Nhiều khối catch và nguyên tắc sắp xếp exception (THEORY)
- Bài 10: Thực hành xử lý lỗi và dọn dẹp tài nguyên kiểm thử (EXERCISE)
- Bài 11: Chủ động phát sinh và lan truyền lỗi với throw và throws (THEORY)
- Bài 12: Custom Exception cho lỗi nghiệp vụ trong framework kiểm thử (THEORY)
- Bài 13: Thực hành xây dựng TestFailedException và logic retry cho flaky test (EXERCISE)
- Bài 14: Interface: Hợp đồng hành vi và lập trình hướng interface (THEORY)
- Bài 15: Thực hành mô phỏng WebDriver đa trình duyệt bằng interface (EXERCISE)
- Bài 16: Phương thức default và khả năng mở rộng interface (THEORY)
- Bài 17: Multiple Interfaces: Kết hợp nhiều khả năng cho phần tử kiểm thử (THEORY)
- Bài 18: Thực hành xây dựng TextBox từ Clickable và Typeable (EXERCISE)
- Bài 19: Kiểm tra tổng hợp về Collection, Exception và Interface (QUIZ)

````

---

### Khóa học: SQL dành cho QA engineer

- Giá: 35.000đ
- Chương: 4
- Bài học đã xuất bản: 43
- HTML: https://t5edu.site/courses/sql-danh-cho-qa-engineer
- Markdown: https://t5edu.site/courses/sql-danh-cho-qa-engineer.md

````markdown
### Mô tả khóa học: SQL dành cho QA engineer

## Giới thiệu

SQL là chiếc cầu nối giúp QA Engineer đi từ việc quan sát lỗi trên giao diện đến việc hiểu, kiểm chứng và truy vết dữ liệu phía sau hệ thống. Khoá học **SQL cơ bản cho QA engineer** được xây dựng từ những tình huống gần với công việc thực tế, giúp bạn không chỉ viết được câu lệnh mà còn biết đặt đúng câu hỏi với dữ liệu. Sau khoá học, SQL sẽ trở thành công cụ hỗ trợ bạn xác minh nghiệp vụ, cô lập test data và phát hiện bất thường một cách có căn cứ.

## Bạn sẽ học được gì?

- Hiểu cách dữ liệu được tổ chức và liên kết giữa các bảng **users**, **orders**, **products** và **order_items** để xác định đúng nguồn dữ liệu cần kiểm tra.
- Viết truy vấn **SELECT** rõ ràng, sử dụng **alias**, điều kiện lọc và sắp xếp để nhanh chóng cô lập test data phục vụ kiểm thử.
- Xác minh các tình huống phổ biến như tìm kiếm, định dạng email, khoảng ngày, thứ tự hiển thị và dữ liệu thiếu bằng **WHERE**, **LIKE**, **BETWEEN**, **ORDER BY** và **IS NULL**.
- Kết hợp dữ liệu nhiều bảng với **INNER JOIN** và **LEFT JOIN** để kiểm tra tính toàn vẹn quan hệ, giao dịch và phát hiện bản ghi bất thường.
- Đối chiếu số liệu đơn hàng, doanh thu và báo cáo bằng **COUNT**, **SUM**, **AVG**, **GROUP BY**, **HAVING** và **subquery** trong các kịch bản QA thực tế.

## Đối tượng phù hợp

- QA/Tester mới bắt đầu muốn trang bị kỹ năng kiểm thử database theo lộ trình rõ ràng và có thể áp dụng vào công việc.
- Manual Tester muốn tự tin xác minh dữ liệu backend thay vì chỉ dừng ở việc kiểm tra giao diện.
- Sinh viên hoặc người chuyển ngành đang định hướng phát triển trong lĩnh vực kiểm thử phần mềm.

---

## Nội dung khoá học

### Chương 1: Truy vấn cơ bản và lọc dữ liệu trong SQL

Chương học đặt nền móng để bạn tiếp cận database bằng tư duy của một QA Engineer: hiểu dữ liệu được tổ chức ra sao, biết chọn đúng bảng và truy xuất đúng thông tin cần kiểm tra. Bạn sẽ thực hành xây dựng truy vấn **SELECT**, sử dụng **alias** để kết quả dễ đọc, đồng thời làm chủ các kỹ thuật **lọc dữ liệu** theo điều kiện, mẫu ký tự, khoảng giá trị và trạng thái thiếu dữ liệu. Qua những tình huống gắn với người dùng, đơn hàng, sản phẩm và chi tiết đơn hàng, bạn sẽ biết cách cô lập test data, xác minh **thứ tự hiển thị**, kiểm tra điều kiện biên và phát hiện các bản ghi chưa đầy đủ trong hệ thống.

### Chương 2: Kết hợp bảng và tổng hợp dữ liệu trong SQL

Từ khả năng truy vấn và lọc dữ liệu ở chương trước, bạn sẽ tiếp tục mở rộng góc nhìn sang những tình huống mà dữ liệu cần xác minh nằm ở nhiều bảng khác nhau. Chương học giúp bạn sử dụng **JOIN** để kết nối thông tin người dùng, đơn hàng và sản phẩm; hiểu rõ ý nghĩa thực tế của **INNER JOIN** và **LEFT JOIN** khi kiểm tra tính toàn vẹn giao dịch hoặc phát hiện quan hệ dữ liệu bị thiếu. Bên cạnh đó, bạn sẽ ứng dụng các hàm **tổng hợp dữ liệu** cùng **GROUP BY** và **HAVING** để đối chiếu số lượng, doanh thu và các chỉ số báo cáo, từ đó đánh giá chính xác hơn tính nhất quán của dữ liệu hệ thống.

### Chương 3: Subquery và xác minh dữ liệu trong các kịch bản QA thực tế

Khi đã có nền tảng về truy vấn, lọc, kết hợp và tổng hợp dữ liệu, bạn sẽ tiến đến các kịch bản xác minh gần hơn với công việc QA hằng ngày. Chương này giúp bạn vận dụng **subquery** để xử lý các điều kiện dữ liệu phức tạp, chẳng hạn tìm người dùng có giá trị đơn hàng cao hơn mức trung bình hoặc sản phẩm chưa từng được đặt hàng. Bạn cũng sẽ thực hành đối chiếu dữ liệu sau thao tác đăng ký qua giao diện hoặc API, kiểm tra tổng tiền đơn hàng với giá trị sản phẩm và phát hiện **email trùng lặp** bằng tư duy kiểm tra dữ liệu có hệ thống. Đồng thời, nội dung về hiệu năng giúp bạn biết cân nhắc giữa **subquery** và **JOIN** để lựa chọn cách truy vấn phù hợp trong từng bối cảnh.

### Chương 4: Thực hành truy vấn SQL trong các kịch bản QA

Chương cuối là nơi bạn kết nối toàn bộ kiến thức đã học thành quy trình xử lý một yêu cầu kiểm thử dữ liệu thực tế. Bạn sẽ rèn luyện cách phân tích điều kiện nghiệp vụ, kết hợp **WHERE**, **ORDER BY**, **JOIN**, hàm tổng hợp và **HAVING** để kiểm tra người dùng theo trạng thái, quốc gia, thời điểm đăng ký, số lượng đơn hàng và doanh thu. Qua các bài thực hành đối chiếu dữ liệu, bạn sẽ củng cố khả năng lựa chọn truy vấn phù hợp, đọc kết quả có căn cứ và biến SQL thành một kỹ năng thiết yếu giúp quá trình kiểm thử chính xác, chủ động và hiệu quả hơn.

### Nội dung học: SQL dành cho QA engineer

#### Chương 1: Truy vấn cơ bản và lọc dữ liệu trong SQL

- Bài 1: SQL và ứng dụng trong kiểm thử database (THEORY)
- Bài 2: Khám phá schema users, orders, products và order_items (THEORY)
- Bài 3: Truy xuất dữ liệu với SELECT và đặt alias cho cột (THEORY)
- Bài 4: Thực hành kiểm tra dữ liệu bằng SELECT (EXERCISE)
- Bài 5: Lọc dữ liệu với WHERE, AND, OR và IN (THEORY)
- Bài 6: Thực hành cô lập test data bằng các điều kiện lọc (EXERCISE)
- Bài 7: Sắp xếp kết quả với ORDER BY (THEORY)
- Bài 8: Thực hành xác minh thứ tự hiển thị dữ liệu (EXERCISE)
- Bài 9: Tìm kiếm theo mẫu với LIKE và ký tự đại diện (THEORY)
- Bài 10: Thực hành kiểm thử tìm kiếm và định dạng email (EXERCISE)
- Bài 11: Lọc dữ liệu theo khoảng với BETWEEN (THEORY)
- Bài 12: Thực hành kiểm tra khoảng ngày và điều kiện biên (EXERCISE)
- Bài 13: Phát hiện dữ liệu thiếu với IS NULL và IS NOT NULL (THEORY)
- Bài 14: Thực hành tìm bản ghi không đầy đủ trong database (EXERCISE)
- Bài 15: Ôn tập truy vấn, lọc và sắp xếp dữ liệu dành cho QA (QUIZ)

#### Chương 2: Kết hợp bảng và tổng hợp dữ liệu trong SQL

- Bài 1: Kết hợp dữ liệu giữa các bảng bằng JOIN (THEORY)
- Bài 2: INNER JOIN: Truy vấn user có đơn hàng hợp lệ (THEORY)
- Bài 3: Thực hành INNER JOIN để đối chiếu dữ liệu giao dịch (EXERCISE)
- Bài 4: LEFT JOIN: Giữ lại user chưa có dữ liệu đơn hàng (THEORY)
- Bài 5: Thực hành phân biệt kết quả INNER JOIN và LEFT JOIN (EXERCISE)
- Bài 6: Tìm quan hệ bị thiếu bằng LEFT JOIN và WHERE IS NULL (THEORY)
- Bài 7: Thực hành tìm user chưa từng đặt hàng (EXERCISE)
- Bài 8: Các hàm tổng hợp COUNT, SUM, AVG, MAX và MIN (THEORY)
- Bài 9: Thực hành xác minh chỉ số đơn hàng và doanh thu (EXERCISE)
- Bài 10: GROUP BY và HAVING trong kiểm tra dữ liệu báo cáo (THEORY)
- Bài 11: Thực hành đếm và lọc số lượng user theo nhóm email (EXERCISE)
- Bài 12: Kiểm tra kiến thức về JOIN và Aggregation (QUIZ)

#### Chương 3: Subquery và xác minh dữ liệu trong các kịch bản QA thực tế

- Bài 1: Subquery và cách lồng truy vấn để lọc dữ liệu phức tạp (THEORY)
- Bài 2: Thực hành tìm user có đơn hàng cao hơn mức trung bình (EXERCISE)
- Bài 3: Thực hành tìm bài học chưa từng được mua bằng NOT IN (EXERCISE)
- Bài 4: Hiệu năng của subquery và lựa chọn giữa subquery với JOIN (THEORY)
- Bài 5: Xác minh dữ liệu user sau khi đăng ký (EXERCISE)
- Bài 6: Đối chiếu tổng tiền đơn hàng với tổng giá trị các sản phẩm (EXERCISE)
- Bài 7: Phát hiện user trùng lặp bằng GROUP BY và HAVING (EXERCISE)
- Bài 8: Ôn tập subquery và các kịch bản xác minh dữ liệu (QUIZ)

#### Chương 4: Thực hành truy vấn SQL trong các kịch bản QA

- Bài 1: Phân tích yêu cầu dữ liệu từ các kịch bản kiểm thử thực tế (THEORY)
- Bài 2: Lọc học viên T5Edu và sắp xếp theo ngày đăng ký (EXERCISE)
- Bài 3: Kiểm tra cách kết hợp WHERE, AND và ORDER BY (QUIZ)
- Bài 4: Đối chiếu tổng số đơn hàng và doanh thu của từng user (EXERCISE)
- Bài 5: Phân biệt vai trò của LEFT JOIN, COUNT, SUM và GROUP BY (QUIZ)
- Bài 6: Xác minh user có hơn 5 đơn hàng trong 30 ngày (EXERCISE)
- Bài 7: Kiểm tra lựa chọn INNER JOIN, bộ lọc thời gian và HAVING (QUIZ)
- Bài 8: Tổng kết kỹ năng SQL thiết yếu cho QA Engineer (THEORY)

````

---

### Khóa học: API Testing nâng cao

- Giá: 39.000đ
- Chương: 13
- Bài học đã xuất bản: 94
- HTML: https://t5edu.site/courses/api-testing-nang-cao
- Markdown: https://t5edu.site/courses/api-testing-nang-cao.md

````markdown
### Mô tả khóa học: API Testing nâng cao

## Giới thiệu
Khóa học **API Testing nâng cao** được thiết kế để giúp học viên hiểu đúng bản chất của **API**, cách nó kết nối **client** với **server**, và vai trò của kiểm thử API trong phát triển sản phẩm. Thay vì học rời rạc từng công cụ hay khái niệm, khóa học dẫn dắt người học đi từ nền tảng đến thực hành theo một lộ trình rõ ràng, thực tế và dễ tiếp cận.

## Bạn sẽ học được gì?
- Hiểu **API** là gì và cách nó kết nối **client** với **server**
- Phân biệt **request** và **response** trong luồng giao tiếp API
- Nhận biết sự khác nhau giữa **JSON** và **XML** trong dữ liệu trao đổi
- Giải thích được vì sao **test API** cần được thực hiện trong quá trình phát triển dự án
- Làm quen với **Postman**, **Collections**, **Environments** và cách đọc **response**

## Đối tượng phù hợp
- Người mới bắt đầu tìm hiểu về **API Testing** và cần nền tảng vững chắc
- Học viên muốn hiểu cách API vận hành trước khi đi sâu vào kiểm thử thực hành
- Người học cần nắm các khái niệm cốt lõi để chuẩn bị cho nội dung nâng cao hơn

---

## Nội dung khoá học

### Chương 1: API là gì và vì sao cần test API
Chương đầu tiên giúp học viên xây dựng nền tảng tư duy đúng về **API** như một **cầu nối giữa client và server**, từ đó hiểu rõ cách **request** và **response** vận hành trong thực tế. Người học cũng sẽ nhận diện vai trò của **JSON** và **XML** trong trao đổi dữ liệu, đồng thời nắm được lý do vì sao **test API** cần được thực hiện ngay trong quá trình phát triển dự án để hỗ trợ kiểm soát chất lượng từ sớm.

### Chương 2: HTTP, Request và Response trong API
Từ nền tảng về API, học viên sẽ tiếp tục đi vào lớp kỹ thuật quan trọng là **HTTP** và cơ chế giao tiếp giữa **client** với **server**. Chương này giúp người học hiểu cấu trúc của một **request** gồm **URL**, **method**, **header** và **body**, đồng thời biết cách đọc **response** qua **status code**, header và body. Khi nắm chắc các method phổ biến như **GET**, **POST**, **PUT** và **DELETE**, học viên sẽ có nền tảng để phân tích API chính xác và có hệ thống hơn.

### Chương 3: JSON, XML và Header định dạng dữ liệu
Sau khi hiểu cách request và response hoạt động, học viên sẽ bước sang phần quan trọng là cách dữ liệu được biểu diễn và trao đổi trong API. Chương này giúp người học phân biệt rõ **JSON** và **XML**, nhận biết cấu trúc của từng định dạng, đồng thời hiểu vai trò của **Content-Type** và **Accept** trong việc xác định cách client và server giao tiếp với nhau. Từ đó, học viên có thêm năng lực phát hiện lỗi giao tiếp và xử lý tình huống thực tế chính xác hơn.

### Chương 4: Làm quen với Postman
Khi đã nắm được cách API vận hành và dữ liệu được trao đổi như thế nào, học viên sẽ bắt đầu làm quen với **Postman** như một công cụ hỗ trợ kiểm thử API phổ biến. Chương này giúp người học hiểu **ưu điểm, nhược điểm**, cách cài đặt và các thành phần chính trong giao diện, từ đó biết cách tổ chức **Settings**, **Collections**, **Request**, **Response** và **Environments** trong một quy trình làm việc rõ ràng. Đây là bước chuyển quan trọng để học viên sẵn sàng tiếp cận môi trường kiểm thử thực tế một cách có hệ thống.

### Chương 5: Tạo Request GET và POST trong Postman
Sau khi làm quen với Postman, học viên sẽ bước sang giai đoạn thực hành quan trọng hơn: tạo và phân tích **request GET** và **POST** trong môi trường kiểm thử. Chương này giúp người học hiểu rõ các thành phần của một API request, biết cách điền **Params** đúng cho GET và nhập dữ liệu trong **Body** cho POST, đồng thời đọc được **response** qua định dạng dữ liệu, nội dung, **status** và thời gian trả về. Từ đó, học viên không chỉ thao tác được trên công cụ mà còn biết cách đối chiếu kết quả với **API docs** và dữ liệu **DB** để đánh giá API có cơ sở.

### Chương 6: Collections trong Postman
Sau khi đã biết cách tạo và đọc từng request riêng lẻ, học viên sẽ học cách tổ chức công việc khoa học hơn với **Collection** trong Postman. Chương này giúp người học hiểu vì sao Collection quan trọng trong việc quản lý, lưu trữ và tái sử dụng các request, đồng thời biết cách tạo mới, đặt tên, mô tả và lưu request từ nhiều nguồn khác nhau. Khi nắm được các thiết lập chính và cách quan sát chức năng trong menu Collection, học viên sẽ có tư duy làm việc có hệ thống hơn, thuận lợi cho việc mở rộng sang các quy trình kiểm thử API phức tạp hơn sau này.

### Chương 7: Environments và biến trong Postman
Từ việc tổ chức request bằng Collection, học viên sẽ tiếp tục mở rộng sang cách quản lý bối cảnh làm việc với **Environment** và **biến** trong Postman. Chương này giúp người học hiểu cách tạo Environment, khai báo và sử dụng biến với cú pháp **{{ten_bien}}**, đồng thời biết cách xem, chỉnh sửa và theo dõi trạng thái active của môi trường. Khi làm chủ được phần này, học viên sẽ có khả năng tái sử dụng cấu hình linh hoạt hơn, kiểm soát giá trị biến rõ ràng hơn và làm việc hiệu quả hơn trong các tình huống kiểm thử thực tế.

### Chương 8: Test Response và lưu biến từ Response trong Postman
Sau khi đã biết cách cấu hình môi trường làm việc, học viên sẽ tiến thêm một bước quan trọng là kiểm tra kết quả trả về và khai thác dữ liệu từ **response**. Chương này giúp người học hiểu vai trò của **Test Response** trong Postman, biết cách đọc cấu trúc **JSON response** để xác định đúng đường dẫn field, đồng thời viết test để kiểm tra dữ liệu như **user_id** và lưu **token** vào **Environment**. Đây là bước hoàn thiện tư duy kiểm thử API, vì học viên không chỉ gửi request và đọc kết quả, mà còn biết xác thực dữ liệu, phát hiện lỗi sai kiểu dữ liệu và tái sử dụng thông tin từ response trong các bước kiểm thử tiếp theo.

### Chương 9: Pre-request Script trong Postman
Khi đã nắm được cách kiểm tra response và lưu biến, học viên sẽ tiến thêm một bước để tạo ra các request linh hoạt hơn bằng **Pre-request Script**. Chương này giúp người học hiểu script được chạy ở bước nào, vì sao nó hữu ích trong việc tạo dữ liệu động và cách ứng dụng để giảm thao tác sửa tay tham số API. Từ việc tạo **departure_datetime** theo thời gian hiện tại, sinh ngẫu nhiên **source** và **destination**, đến lưu giá trị bằng **pm.environment.set**, học viên sẽ hình thành tư duy tự động hóa những phần lặp lại trong kiểm thử và thiết kế request có khả năng thích nghi tốt hơn với nhiều tình huống thực tế.

### Chương 10: Xây dựng API Document trong Postman
Ở chặng tiếp theo, học viên sẽ học cách biến các request đã xây dựng thành một **API Document** có cấu trúc rõ ràng trong Postman. Chương này giúp người học hiểu các thành phần của tài liệu API, biết cách mô tả từng API bằng **Markdown**, khai báo **Params** và **Body** đúng cách, đồng thời tạo **Example** để hình thành **Sample Request** và **Sample Response**. Khi hoàn thiện được phần này, học viên không chỉ kiểm thử API mà còn biết cách trình bày tài liệu một cách mạch lạc, thuận tiện cho việc chia sẻ, theo dõi và sử dụng trong thực tế.

### Chương 11: Quản lý Test Suites và chạy Runner trong Postman
Sau khi đã xây dựng được request, collection, environment và tài liệu API, học viên sẽ học cách tổ chức các **Test Suites** theo task để làm việc hiệu quả hơn trong Postman. Chương này giúp người học biết cách tách từng trường hợp kiểm thử thành request riêng, hiểu mục đích của **Runner** và cách đọc report sau khi chạy qua các phần như **Summary**, **Pass/Fail** và log. Từ đó, học viên có thể quản lý bộ kiểm thử rõ ràng hơn, theo dõi kết quả có hệ thống hơn và vận dụng Runner như một bước quan trọng trong quy trình kiểm thử API thực tế.

### Chương 12: Cách test API và tổ chức test scenario
Chương cuối cùng giúp học viên nối toàn bộ kiến thức đã học để hiểu **API được dùng để test gì** trong hệ thống client-server, từ đó phân biệt rõ **Syntax Testing** và **Functional Testing** trong API. Người học sẽ biết cách kiểm tra validate dữ liệu, đối chiếu **response** với **database**, và tổ chức **test scenario** từ nhiều API theo nguyên tắc tách từng API riêng biệt trong Postman. Đây là bước hoàn thiện tư duy kiểm thử có hệ thống, giúp học viên không chỉ thao tác đúng công cụ mà còn biết cách xây dựng kịch bản kiểm thử sát với thực tế dự án.

### Chương 13: Lưu ý khi xây dựng và chạy API Test trong Postman
Ở chương cuối, học viên sẽ được củng cố những lưu ý quan trọng để vận hành bộ kiểm thử API ổn định hơn trong Postman. Nội dung tập trung vào cách tổ chức **Workspace**, sử dụng **Console Log** để debug, kiểm tra **Error Code** và xác minh **Response Data**, đồng thời quản lý **Environment** với cách đặt tên biến có ý nghĩa. Bên cạnh đó, học viên còn được nhấn mạnh tầm quan trọng của việc chuẩn bị **test data** và **DB** trước khi chạy test, từ đó hình thành thói quen làm việc cẩn thận, có kế hoạch và phù hợp với thực tế kiểm thử.

### Nội dung học: API Testing nâng cao

#### Chương 1: API là gì và vì sao cần test API

- Bài 1: Khái niệm API: cầu nối giữa client và server (THEORY)
- Bài 2: Ví dụ request và response qua tình huống hướng dẫn viên du lịch (THEORY)
- Bài 3: Bài tập phân tích vai trò client, server, request, response trong ví dụ thực tế (EXERCISE)
- Bài 4: Định dạng dữ liệu trong API: XML và JSON (THEORY)
- Bài 5: Vì sao cần test API trong quá trình phát triển dự án (THEORY)
- Bài 6: Trắc nghiệm nhanh: khái niệm API và lý do test API (QUIZ)

#### Chương 2: HTTP, Request và Response trong API

- Bài 1: Protocol và vai trò của HTTP trong API (THEORY)
- Bài 2: Cơ chế request - response giữa client và server (THEORY)
- Bài 3: Cấu trúc request: URL, method, header, body (THEORY)
- Bài 4: Bài tập phân tích thành phần của một request (EXERCISE)
- Bài 5: Các method phổ biến: GET, POST, PUT, DELETE (THEORY)
- Bài 6: Cấu trúc response: status code, header, body (THEORY)
- Bài 7: Trắc nghiệm nhanh về HTTP, request và response (QUIZ)

#### Chương 3: JSON, XML và Header định dạng dữ liệu

- Bài 1: Tổng quan về định dạng dữ liệu JSON và XML trong API (THEORY)
- Bài 2: Cấu trúc JSON: key, value và dữ liệu lồng nhau (THEORY)
- Bài 3: Phân biệt nhanh JSON và XML qua ví dụ cấu trúc dữ liệu (QUIZ)
- Bài 4: Cấu trúc XML: thẻ và node trong biểu diễn dữ liệu (THEORY)
- Bài 5: Vai trò của Content-Type trong request và response (THEORY)
- Bài 6: Bài tập xác định Content-Type và Accept phù hợp cho từng tình huống (EXERCISE)
- Bài 7: Header Accept và cách client thông báo định dạng có thể đọc (THEORY)
- Bài 8: Bài tập phân tích lỗi khi client và server dùng khác định dạng dữ liệu (EXERCISE)

#### Chương 4: Làm quen với Postman

- Bài 1: Postman là gì, ưu điểm và nhược điểm (THEORY)
- Bài 2: Cài đặt Postman (THEORY)
- Bài 3: Trắc nghiệm nhanh về Postman cơ bản (QUIZ)
- Bài 4: Các thành phần chính trong giao diện Postman (THEORY)
- Bài 5: Phân biệt Settings, Collections và API content (EXERCISE)
- Bài 6: Environments, Request và Response trong Postman (THEORY)

#### Chương 5: Tạo Request GET và POST trong Postman

- Bài 1: 4 thành phần của một API request (THEORY)
- Bài 2: Cách tạo request GET và điền Params đúng (THEORY)
- Bài 3: Bài tập thực hành tạo request GET trên Postman (EXERCISE)
- Bài 4: Đọc response: định dạng dữ liệu, nội dung, status và thời gian trả về (THEORY)
- Bài 5: Trắc nghiệm nhanh về GET, Params và response (QUIZ)
- Bài 6: Cách tạo request POST và nhập dữ liệu trong Body (THEORY)
- Bài 7: Bài tập thực hành phân tích response theo API docs và dữ liệu DB (EXERCISE)

#### Chương 6: Collections trong Postman

- Bài 1: Collection là gì và vì sao cần dùng trong Postman (THEORY)
- Bài 2: Tạo Collection mới và nhập tên, mô tả (THEORY)
- Bài 3: Lưu request vào Collection từ request mới và từ History (THEORY)
- Bài 4: Bài tập: Xác định lợi ích của Collection so với chỉ dùng History (EXERCISE)
- Bài 5: Các thiết lập chính của Collection trong Postman (THEORY)
- Bài 6: Bài tập thực hành: Quan sát và phân loại chức năng trong menu Collection (EXERCISE)
- Bài 7: Trắc nghiệm: Tạo, lưu và quản lý Collection (QUIZ)

#### Chương 7: Environments và biến trong Postman

- Bài 1: Tổng quan về Environment trong Postman (THEORY)
- Bài 2: Tạo Environment và khai báo biến (THEORY)
- Bài 3: Thực hành tạo một Environment và thêm biến url (EXERCISE)
- Bài 4: Sử dụng biến trong request với cú pháp {{ten_bien}} (THEORY)
- Bài 5: Kiểm tra nhanh: nhận biết biến hợp lệ, biến thiếu và trạng thái active (QUIZ)
- Bài 6: Xem, chỉnh sửa và quản lý Environment (THEORY)
- Bài 7: Thực hành quan sát giá trị biến bằng Manage Environments và biểu tượng con mắt (EXERCISE)

#### Chương 8: Test Response và lưu biến từ Response trong Postman

- Bài 1: Vai trò của Test Response trong Postman (THEORY)
- Bài 2: Đọc cấu trúc JSON response để xác định đúng đường dẫn field (THEORY)
- Bài 3: Viết test kiểm tra user_id trong response login (THEORY)
- Bài 4: Bài tập thực hành: xác định nguyên nhân test fail do sai kiểu dữ liệu (EXERCISE)
- Bài 5: Cập nhật cú pháp test với pm.response.json và pm.expect (THEORY)
- Bài 6: Lưu token từ response vào Environment (THEORY)
- Bài 7: Bài tập thực hành: viết script lấy token và kiểm tra trong Environment (EXERCISE)
- Bài 8: Trắc nghiệm nhanh: phân biệt kiểm tra field và lưu biến từ response (QUIZ)

#### Chương 9: Pre-request Script trong Postman

- Bài 1: Pre-request Script là gì và chạy ở bước nào trong request (THEORY)
- Bài 2: Các trường hợp dùng Pre-request để tạo dữ liệu động cho request (THEORY)
- Bài 3: QUIZ: Phân biệt vai trò của Pre-request Script và Test Script (QUIZ)
- Bài 4: Xử lý Departure_datetime bằng hàm tạo ngày giờ hiện tại phù hợp (THEORY)
- Bài 5: Tạo source và destination ngẫu nhiên từ array và lưu vào Environment (THEORY)
- Bài 6: Thực hành viết Pre-request Script lưu biến bằng pm.environment.set (EXERCISE)
- Bài 7: Ứng dụng Pre-request để giảm việc sửa tay tham số API (THEORY)
- Bài 8: Bài tập thực hành: Thiết kế request với tham số động gồm _user_id, _token, source, destination, departure_datetime (EXERCISE)

#### Chương 10: Xây dựng API Document trong Postman

- Bài 1: Tổng quan API Document trong Postman (THEORY)
- Bài 2: Các thành phần của một API Document (THEORY)
- Bài 3: Thực hành xác định cấu trúc tài liệu API từ Collection và Request (EXERCISE)
- Bài 4: Viết mô tả API Docs và mô tả từng API bằng Markdown (THEORY)
- Bài 5: Khai báo Params và Body khi viết API Docs (THEORY)
- Bài 6: Tạo Example để xây dựng Sample Request và Sample Response (THEORY)
- Bài 7: Trắc nghiệm về thành phần API Docs, Markdown và Example (QUIZ)
- Bài 8: Thực hành hoàn thiện và xem lại API Document qua link Docs (EXERCISE)

#### Chương 11: Quản lý Test Suites và chạy Runner trong Postman

- Bài 1: Cách tổ chức Test Suites theo task trong Postman (THEORY)
- Bài 2: Tách từng trường hợp kiểm thử thành request riêng (THEORY)
- Bài 3: Bài tập: đề xuất cấu trúc request cho một task có nhiều trường hợp test (EXERCISE)
- Bài 4: Runner trong Postman: mục đích và các thành phần cần quan tâm (THEORY)
- Bài 5: Đọc report sau khi chạy Runner: Summary, Pass/Fail và log (THEORY)
- Bài 6: Trắc nghiệm: quản lý request và cách hiểu kết quả Runner (QUIZ)
- Bài 7: Bài tập thực hành: chạy một Folder bằng Runner và quan sát report (EXERCISE)

#### Chương 12: Cách test API và tổ chức test scenario

- Bài 1: API được dùng để test gì trong hệ thống client-server (THEORY)
- Bài 2: Syntax Testing trong API: kiểm tra validate dữ liệu và response (THEORY)
- Bài 3: Quiz: phân biệt Syntax Testing và Functional Testing (QUIZ)
- Bài 4: Functional Testing trong API: kiểm tra business logic và dữ liệu lưu DB (THEORY)
- Bài 5: Viết testcase cho API update_profile với Name và Birthday (TESTCASE)
- Bài 6: Đối chiếu response với database khi test API (THEORY)
- Bài 7: Thực hành xây dựng test scenario từ nhiều API và nguyên tắc tách từng API riêng biệt trong Postman (EXERCISE)

#### Chương 13: Lưu ý khi xây dựng và chạy API Test trong Postman

- Bài 1: Tổ chức Workspace và dùng Console Log để debug (THEORY)
- Bài 2: Quiz: Khi nào cần dùng Console Log trong Postman (QUIZ)
- Bài 3: Kiểm tra Error Code và xác minh Response Data (THEORY)
- Bài 4: Bài tập: Xác định các điểm cần kiểm tra trong response API (EXERCISE)
- Bài 5: Quản lý Environment và đặt tên biến có ý nghĩa (THEORY)
- Bài 6: Bài tập: Thiết kế danh sách biến Environment cho các trường hợp đúng và sai (EXERCISE)
- Bài 7: Chuẩn bị test data và DB để chạy API test ổn định (THEORY)
- Bài 8: Viết testcase: Kế hoạch chuẩn bị dữ liệu trước khi chạy bộ API test (TESTCASE)

````

---

### Khóa học: API Testing cơ bản

- Giá: Miễn phí
- Chương: 3
- Bài học đã xuất bản: 31
- HTML: https://t5edu.site/courses/api-testing-co-ban
- Markdown: https://t5edu.site/courses/api-testing-co-ban.md

````markdown
### Mô tả khóa học: API Testing cơ bản

## Giới thiệu
API Testing cơ bản được xây dựng để giúp học viên nhìn API Testing như một phần thiết yếu của kiểm thử phần mềm hiện đại, thay vì chỉ là một thao tác kỹ thuật rời rạc. Khoá học tập trung vào **tư duy kiểm thử**, **cấu trúc test** và cách đặt API Testing đúng vị trí trong **quy trình phát triển** và **CI/CD**.

## Bạn sẽ học được gì?
- Hiểu vị trí của **API Testing** trong **test pyramid** và phạm vi kiểm thử tích hợp
- Xác định được **khi nào nên test**, **cần test gì** và mục tiêu của từng kiểm thử API
- Nắm được vai trò của API Testing trong **CI/CD pipeline** và cách lựa chọn công cụ phù hợp
- Biết cách đọc và phân tích một **API test** theo cấu trúc **Setup - Action - Check result**
- Thực hành tư duy kiểm thử theo **AAA** và **Given-When-Then** để tổ chức test rõ ràng hơn

## Đối tượng phù hợp
- Người mới bắt đầu tìm hiểu về **API Testing** và muốn có nền tảng đúng ngay từ đầu
- Học viên đang học kiểm thử phần mềm và cần hiểu cách API Testing gắn với quy trình phát triển thực tế
- Tester muốn hệ thống lại tư duy thiết kế test trước khi đi sâu vào công cụ hoặc tự động hoá

---

## Nội dung khoá học

### Chương 1: Tổng quan và cấu trúc API Testing
Chương này giúp học viên xây dựng nền tảng đầu tiên để nhìn API Testing một cách có hệ thống. Bạn sẽ hiểu **vì sao API Testing quan trọng**, nó nằm ở đâu trong **test pyramid**, nên được áp dụng vào thời điểm nào trong quy trình kiểm thử, và liên hệ như thế nào với **CI/CD pipeline**. Từ đó, học viên sẽ nắm được cách một API test được tổ chức theo **Setup, Action, Check result**, đồng thời biết cách phân tích test case theo **AAA** và **Given-When-Then** để viết kiểm thử rõ ràng, dễ đọc và dễ bảo trì hơn.

### Chương 2: Nền tảng API: cấu trúc, dữ liệu và xác thực
Sau khi đã có tư duy tổng quan, học viên sẽ đi vào phần nền tảng kỹ thuật của API để hiểu cách giao tiếp giữa client và server diễn ra như thế nào. Chương này giúp bạn nắm được **request**, **response**, **HTTP method**, **status code**, cũng như cách dữ liệu được truyền qua **JSON**, **XML** và các header như **Content-Type** và **Accept**. Bên cạnh đó, học viên còn được tiếp cận các cơ chế xác thực phổ biến như **Basic Auth**, **API Key** và **OAuth2**, từ đó biết cách đọc một request login, nhận diện dữ liệu đầu vào từ UI và viết **testcase** cho API dựa trên request, response và authentication một cách có hệ thống.

### Chương 3: Cách test API và xử lý dữ liệu kiểm thử
Khi đã hiểu cấu trúc và nền tảng giao tiếp của API, học viên sẽ chuyển sang cách kiểm thử có mục tiêu và có phương pháp hơn. Chương này giúp bạn phân biệt ba hướng kiểm thử chính là **Syntax**, **Functional** và **Flow**, từ đó biết cách xác định lỗi hợp lệ, kiểm tra hành vi nghiệp vụ và đánh giá luồng sử dụng theo góc nhìn người dùng. Học viên cũng sẽ làm quen với cách chuẩn bị **test data**, lựa chọn nguồn dữ liệu phù hợp và xây dựng **assertion** rõ ràng để kiểm tra kết quả đầu ra một cách chặt chẽ, nhất quán và sát với thực tế kiểm thử.

### Nội dung học: API Testing cơ bản

#### Chương 1: Tổng quan và cấu trúc API Testing

- Bài 1: API Testing trong test pyramid và phạm vi tích hợp (THEORY)
- Bài 2: Vì sao API Testing quan trọng, cần test gì và khi nào nên test (THEORY)
- Bài 3: Quiz: Nhận diện mục tiêu và thời điểm áp dụng API Testing (QUIZ)
- Bài 4: API Testing trong CI/CD pipeline và lựa chọn công cụ (THEORY)
- Bài 5: Cấu trúc một API test: Setup, Action, Check result (THEORY)
- Bài 6: Thực hành phân tích một API test theo AAA và Given-When-Then (EXERCISE)

#### Chương 2: Nền tảng API: cấu trúc, dữ liệu và xác thực

- Bài 1: API là gì và vai trò của interface trong giao tiếp client-server (THEORY)
- Bài 2: Protocol, HTTP và vòng đời request-response (THEORY)
- Bài 3: Phân tích cấu trúc request: URL, Method, Header, Body (THEORY)
- Bài 4: Quiz: Nhận diện thành phần của request và ý nghĩa HTTP method (QUIZ)
- Bài 5: Phân tích cấu trúc response và nhóm status code cơ bản (THEORY)
- Bài 6: API dưới giao diện người dùng: liên hệ giữa UI và API (THEORY)
- Bài 7: Bài tập: Đọc một request login và xác định dữ liệu đầu vào từ UI (EXERCISE)
- Bài 8: Định dạng dữ liệu trong API: JSON và XML (THEORY)
- Bài 9: Sử dụng Content-Type và Accept trong HTTP header (THEORY)
- Bài 10: Quiz: Phân biệt JSON, XML, Content-Type và Accept (QUIZ)
- Bài 11: Các cơ chế xác thực phổ biến: Basic Auth, API Key và OAuth2 (THEORY)
- Bài 12: Bài tập thực hành: Xác định cách gửi thông tin xác thực trong từng cơ chế authentication (EXERCISE)
- Bài 13: Viết testcase cho API login dựa trên request, response và authentication (TESTCASE)

#### Chương 3: Cách test API và xử lý dữ liệu kiểm thử

- Bài 1: Tổng quan 3 hướng kiểm thử API: Syntax, Functional, Flow (THEORY)
- Bài 2: Syntax Testing: kiểm tra require fields, validation rules và token (THEORY)
- Bài 3: Quiz: phân biệt lỗi 400, 401 và 403 trong API Testing (QUIZ)
- Bài 4: Functional Testing: positive, negative và ví dụ Filter Student (THEORY)
- Bài 5: Testcase: lập bảng test case cho API Filter Student (TESTCASE)
- Bài 6: Flow Testing: short flow và long flow theo hành vi người dùng (THEORY)
- Bài 7: Các loại API cơ bản: GET, POST, PUT, DELETE và mục tiêu sử dụng (THEORY)
- Bài 8: Quiz: chọn method và status code phù hợp cho từng tình huống (QUIZ)
- Bài 9: Chuẩn bị test data từ script, file ngoài và response API khác (THEORY)
- Bài 10: Exercise: xác định nguồn test data phù hợp cho từng loại dữ liệu (EXERCISE)
- Bài 11: Assertion trong API Testing: assert one và assert all (THEORY)
- Bài 12: Exercise: phân tích yêu cầu assertion từ response danh sách sách (EXERCISE)

````

---

### Khóa học: Testing cơ bản

- Giá: Miễn phí
- Chương: 11
- Bài học đã xuất bản: 107
- HTML: https://t5edu.site/courses/testing-co-ban
- Markdown: https://t5edu.site/courses/testing-co-ban.md

````markdown
### Mô tả khóa học: Testing cơ bản

## Giới thiệu
Khóa học **Testing cơ bản** cung cấp nền tảng cần thiết để bắt đầu với kiểm thử phần mềm, phù hợp cho người mới học, sinh viên hoặc người muốn hệ thống lại kiến thức nền tảng về Tester. Nội dung khóa học giúp người học hiểu vai trò của kiểm thử trong dự án, nắm quy trình phát triển phần mềm, làm quen với tài liệu kiểm thử và thực hành các kỹ thuật kiểm thử cơ bản.

## Bạn sẽ học được gì?
- Hiểu tổng quan về kiểm thử phần mềm, vai trò của Tester và vị trí của kiểm thử trong dự án
- Nắm được quy trình sản xuất phần mềm, Software Life Cycle và cách kiểm thử gắn với từng giai đoạn phát triển
- Biết cách đọc và sử dụng các tài liệu cơ bản như SRS, Prototype, Testcase, Bug Log, Test Plan và Test Report
- Xây dựng testcase cơ bản từ yêu cầu chức năng đơn giản, thực hành ghi nhận lỗi và phân biệt Severity, Priority
- Phân biệt các phương pháp, mức kiểm thử và kỹ thuật thiết kế test như Black Box, White Box, Gray Box, Equivalence Partitioning, Boundary Value Analysis, Decision Table và Error Guessing

## Đối tượng phù hợp
- Người mới bắt đầu tìm hiểu về kiểm thử phần mềm
- Sinh viên hoặc người chuyển ngành muốn làm quen với nghề Tester
- Người đã có kiến thức nền về phần mềm và cần hệ thống lại các khái niệm kiểm thử cơ bản

---

### Chương 1: Nhập môn kiểm thử
Sau khi hoàn thành, bạn nắm chắc vai trò của Tester trong toàn bộ vòng đời dự án, hiểu rõ quy trình kiểm thử từ yêu cầu đến quản lý lỗi, và biết cách đọc các tài liệu quan trọng (SRS, Prototype, Test Plan…). Bạn có thể tự viết testcase cơ bản cho một chức năng đơn giản và hiểu sự khác biệt giữa Black Box & White Box.

### Chương 2: Mô hình phát triển phần mềm
Bạn sẽ hiểu sâu cách kiểm thử hoạt động trong từng mô hình (Waterfall, V-Model, Agile/Scrum), biết Tester làm gì ở mỗi giai đoạn, và có khả năng so sánh ưu nhược điểm của từng mô hình từ góc nhìn thực tế của người kiểm thử.

### Chương 3: Kỹ thuật và mức kiểm thử
Bạn thành thạo các kỹ thuật Black Box cốt lõi (Phân vùng tương đương, Giá trị biên, Bảng quyết định, Error Guessing) và biết chọn mức kiểm thử phù hợp (Unit → Acceptance). Kết quả là bạn có thể tự thiết kế testcase chuyên nghiệp, giảm số lượng testcase mà vẫn bao quát đầy đủ rủi ro.

### Chương 4: Quy trình và quản lý lỗi
Bạn biết xây dựng Test Plan, viết Test Case & Test Report chuẩn, phân biệt Severity/Priority, hiểu rõ vòng đời Bug, và nắm vững khái niệm QA/QC, Verification/Validation, Re-test/Regression. Bạn có thể tự quản lý lỗi và báo cáo tiến độ kiểm thử cho dự án thực tế.

### Chương 5: Thiết kế test cho form
Bạn nắm vững cách phân tích form nghiệp vụ và viết testcase chi tiết cho mọi loại trường (textbox, droplist, radio, checkbox, calendar, CKEditor…). Kết quả: bạn có bộ testcase hoàn chỉnh cho bất kỳ form thêm mới/tìm kiếm nào, bao gồm cả validation và edge case.

### Chương 6: Hướng dẫn viết Test Case
Bạn học được cách viết testcase rõ ràng, dễ bảo trì, phân loại normal/abnormal/boundary case. Qua thực hành bạn sẽ viết được testcase chuẩn cho textbox và chức năng đăng nhập, đồng thời biết cách rà soát & cải thiện bộ testcase kém chất lượng.

### Chương 7: SQL cơ bản cho Tester
Bạn hiểu cách truy vấn dữ liệu để hỗ trợ kiểm thử, nắm vững các lệnh SELECT, INSERT, UPDATE, DELETE cơ bản và có thể đọc hiểu query để kiểm tra dữ liệu trong database.

### Chương 8: Kiểm thử hiệu năng với JMeter cơ bản
Bạn nắm được quy trình kiểm thử hiệu năng, biết ghi script, thêm assertion, chạy test và đọc báo cáo JMeter. Bạn có thể tự thực hiện kiểm thử load/performance cơ bản cho một trang web.

### Chương 9: Thiết kế test cho chức năng chuyển tiền ngân hàng
Bạn biết phân tích yêu cầu nghiệp vụ phức tạp và viết testcase hoàn chỉnh cho luồng chuyển khoản (ngân hàng, số tài khoản, số tiền, nội dung, lưu người thụ hưởng…). Đây là bài thực hành nâng cao giúp bạn áp dụng tất cả kỹ năng đã học.

### Chương 10: CV và ứng tuyển cho Tester
Bạn có CV Tester chuyên nghiệp, biết cách trình bày kinh nghiệm, kỹ năng, dự án, viết email xin việc chuẩn và chuẩn bị tâm lý, thái độ cho phỏng vấn. Bạn sẽ tự tin ứng tuyển vị trí Tester fresher/intern.

### Chương 11: Bộ test case dùng chung cho ứng dụng web
Bạn nhận được toàn bộ bộ Common Testcases T5Edu (hơn 200 testcase chi tiết) bao quát Authentication, Search & Filter, Form Validation, CRUD, Data Display, Special Fields, Notifications, HRM-CRM-LMS-SaaS, và cả API Testing 2026. Đây là “bí kíp thần thánh” giúp bạn áp dụng ngay vào mọi dự án thực tế.

**Lưu ý quan trọng:**
1. Toàn bộ 11 chương + tất cả bài tập, quiz, thực hành đều **hoàn toàn FREE**.
2. Bạn intern/fresher đang loay hoay viết testcase cho dự án? Bộ Common Testcases T5Edu chính là ‘bí kíp thần thánh’ cover trọn 100% scenario từ UI đến API, HRM-CRM-LMS-SaaS!

### Nội dung học: Testing cơ bản

#### Chương 0: Nhập môn kiểm thử

- Bài 1: Tổng quan kiểm thử phần mềm và vai trò của Tester (THEORY)
- Bài 2: Quy trình sản xuất phần mềm và vị trí của kiểm thử trong dự án (THEORY)
- Bài 3: Bài tập: Xác định công việc của Tester trong từng giai đoạn dự án (EXERCISE)
- Bài 4: Quy trình kiểm thử phần mềm từ yêu cầu đến quản lý lỗi (THEORY)
- Bài 5: Tài liệu quan trọng với Tester: SRS, Prototype, Testcase và Bug Log (THEORY)
- Bài 6: Bài tập: Đọc yêu cầu và viết testcase cơ bản từ một chức năng đơn giản (EXERCISE)
- Bài 7: Phương pháp kiểm thử cơ bản: Black Box và White Box (THEORY)
- Bài 8: All tài liệu học tập ( Biểu mẫu testcase, test plant, test report,... ) (THEORY)

#### Chương 1: Mô hình phát triển phần mềm

- Bài 1: Software Life Cycle và vai trò của kiểm thử trong quy trình phát triển phần mềm (THEORY)
- Bài 2: Mô hình Waterfall: các giai đoạn, đầu ra và vị trí của kiểm thử (THEORY)
- Bài 3: Bài tập: Xác định đầu ra của từng giai đoạn trong quy trình Waterfall và công việc của Tester (EXERCISE)
- Bài 4: Mô hình chữ V: kiểm thử song song với phát triển và lợi ích phát hiện lỗi sớm (THEORY)
- Bài 5: Mô hình Agile/Scrum: Sprint, tính lặp - tăng dần - thích ứng và cách vận hành cơ bản (THEORY)
- Bài 6: Bài tập: So sánh Waterfall, V-Model và Agile/Scrum theo góc nhìn của Tester (EXERCISE)
- Bài 7: Các vai trò, cuộc họp và artifacts trong Scrum: Product Backlog, Sprint Backlog, Daily Scrum, Sprint Review, Retrospective (THEORY)

#### Chương 2: Kỹ thuật và mức kiểm thử

- Bài 0: Phương pháp kiểm thử: Black Box, White Box và Gray Box (THEORY)
- Bài 1: Các mức kiểm thử: Unit Test, Integration Test, System Test và Acceptance Test (THEORY)
- Bài 2: Kỹ thuật Black Box 1: Phân vùng tương đương và cách giảm số lượng test case (THEORY)
- Bài 3: Kỹ thuật Black Box 2: Phân tích giá trị biên và lựa chọn dữ liệu kiểm thử tại vùng biên (THEORY)
- Bài 4: Bài tập: Phân biệt phương pháp kiểm thử và xác định mức kiểm thử phù hợp cho từng tình huống (EXERCISE)
- Bài 5: Kỹ thuật Black Box 3: Bảng quyết định trong các bài toán có nhiều điều kiện đầu vào (THEORY)
- Bài 6: Bài tập: Thiết kế test case bằng Equivalence Partitioning và Boundary Value Analysis (EXERCISE)
- Bài 7: Kỹ thuật Black Box 4: Error Guessing và cách tận dụng kinh nghiệm để tìm lỗi (THEORY)
- Bài 8: Bài tập: Lập bảng quyết định cho chức năng đăng nhập và bổ sung test case theo Error Guessing (EXERCISE)
- Bài 9: Acceptance Testing thực tế: Alpha Test, Beta Test và tiêu chí chấp nhận sản phẩm (THEORY)

#### Chương 3: Quy trình và quản lý lỗi

- Bài 1: Tổng quan quy trình kiểm thử phần mềm và đầu ra của từng bước (THEORY)
- Bài 2: Test Plan: mục tiêu, phạm vi, nguồn lực và kế hoạch kiểm thử dự án (THEORY)
- Bài 3: Bài tập: Phân tích một dự án mẫu và xác định đầu ra kiểm thử gồm Test Plan, Test Case, Test Report (EXERCISE)
- Bài 4: Test Case và Test Execution: cách đặc tả dữ liệu vào, bước thực hiện, kết quả mong đợi và ghi nhận kết quả test (THEORY)
- Bài 5: Test Report: theo dõi tiến độ test, số lượng test case, defects, severity và rủi ro release (THEORY)
- Bài 6: Bài tập: Viết test case cho chức năng đăng nhập và lập báo cáo test ngắn sau khi thực thi (EXERCISE)
- Bài 7: Quản lý lỗi phần mềm: Defect/Bug/Fault, vòng đời bug, cách viết bug và công cụ quản lý lỗi (THEORY)
- Bài 8: Severity và Priority: phân biệt mức độ nghiêm trọng và độ ưu tiên khi xử lý bug (THEORY)
- Bài 9: QA, QC, Verification và Validation: phân biệt vai trò và ý nghĩa trong đảm bảo chất lượng (THEORY)
- Bài 10: Bài tập: Phân loại bug theo severity/priority, viết bug report và xác định trạng thái bug phù hợp (EXERCISE)
- Bài 11: Re-test và Regression Test: khi nào cần kiểm tra lại và khi nào cần test hồi quy (THEORY)
- Bài 12: Functional và Non-functional Testing: giới thiệu kiểm thử chức năng, hiệu năng, bảo mật và chịu tải (THEORY)

#### Chương 4: Thiết kế test cho form

- Bài 1: Phân tích màn hình nghiệp vụ và nhóm trường dữ liệu trong form tìm kiếm, thêm mới sản phẩm (THEORY)
- Bài 2: Xác định rule kiểm thử cho trường bắt buộc, không bắt buộc và giá trị mặc định (THEORY)
- Bài 3: Bài tập: Liệt kê điều kiện kiểm tra cho form tìm kiếm sản phẩm và tab thông tin sản phẩm (EXERCISE)
- Bài 4: Thiết kế test case cho textbox: độ dài, rỗng, khoảng trắng, định dạng, ký tự đặc biệt, số và tính duy nhất (THEORY)
- Bài 5: Thiết kế test case cho droplist, radio, checkbox, calendar và hành vi focus/highlight khi validate (THEORY)
- Bài 6: Kiểm thử trường soạn thảo CKEditor: giới hạn ký tự, nội dung rỗng, trim khoảng trắng và định dạng rich text (THEORY)
- Bài 7: Bài tập: Viết test case chi tiết cho các trường Tên sản phẩm, Mã sản phẩm, Số lượng, Số thứ tự và Nội dung tóm tắt (EXERCISE)
- Bài 8: Tổ chức bộ test case theo module, tab chức năng và trạng thái thực thi để dễ theo dõi và bảo trì (THEORY)

#### Chương 5: Hướng dẫn viết Test Case

- Bài 1: Khái niệm test case, mục đích sử dụng và vai trò trong dự án (THEORY)
- Bài 2: Thành phần của test case: mô tả, bước thực hiện, dữ liệu vào và kết quả mong đợi (THEORY)
- Bài 3: Quiz: Nhận diện đúng các thành phần của một test case (QUIZ)
- Bài 4: Cách xác định trường hợp kiểm tra: normal case, abnormal case và boundary case (THEORY)
- Bài 5: Nguyên tắc viết test case hiệu quả: rõ ràng, độc lập, dễ hiểu, dễ tái sử dụng (THEORY)
- Bài 6: Bài tập: Phân loại tình huống kiểm thử thành normal, abnormal và boundary (EXERCISE)
- Bài 7: Viết test case cho textbox: maxlength, bắt buộc nhập và dữ liệu đầu vào (TESTCASE)
- Bài 8: Viết test case cho chức năng đăng nhập với email/điện thoại, mật khẩu và button đăng nhập (TESTCASE)
- Bài 9: Quiz: Lưu ý khi viết test case chức năng và cách ghi nhận test result (QUIZ)
- Bài 10: Bài tập thực hành: Rà soát và cải thiện một bộ test case chưa rõ ràng (EXERCISE)

#### Chương 6: SQL cơ bản cho Tester

- Bài 1: SQL là gì và vai trò của SQL trong truy cập dữ liệu (THEORY)
- Bài 2: Database là gì, bảng dữ liệu là gì và khái niệm record-row (THEORY)
- Bài 3: Quiz: Phân biệt SQL, Database, bảng dữ liệu và record (QUIZ)
- Bài 4: Các hệ quản trị CSDL phổ biến: SQL Server, MySQL và Oracle (THEORY)
- Bài 5: Các lệnh SQL cơ bản: SELECT, INSERT INTO, UPDATE, DELETE (THEORY)
- Bài 6: Bài tập: Xác định mục đích sử dụng phù hợp của từng lệnh SQL cơ bản (EXERCISE)
- Bài 7: Câu lệnh SELECT: mục đích, cấu trúc cơ bản và ý nghĩa dấu * (THEORY)
- Bài 8: Bài tập thực hành: Đọc và giải thích truy vấn SELECT * FROM Employees; (EXERCISE)

#### Chương 7: Kiểm thử hiệu năng với JMeter cơ bản

- Bài 1: Kiểm thử hiệu năng là gì và các chỉ số cơ bản (THEORY)
- Bài 2: JMeter là gì, các dạng kiểm thử hỗ trợ và điều kiện cài đặt (THEORY)
- Bài 3: Quiz: Nhận diện response time, throughput, concurrency và capacity measure (QUIZ)
- Bài 4: Quy trình kiểm thử hiệu năng và biểu mẫu báo cáo kết quả (THEORY)
- Bài 5: Thực hành: Đọc một bảng kết quả hiệu năng và xác định các thông số chính (EXERCISE)
- Bài 6: Các bước thực hiện kiểm thử hiệu năng với JMeter ở mức cơ bản (THEORY)
- Bài 7: Mở JMeter, chọn template và cấu hình Thread Group (THEORY)
- Bài 8: Thực hành: Xác định ý nghĩa Number of Threads, Ramp-Up Period, Forever và Loop Count (EXERCISE)
- Bài 9: Ghi script bằng JMeter và cấu hình proxy trên trình duyệt (THEORY)
- Bài 10: Kiểm tra script bằng View Result Tree và xác nhận script đã được ghi (THEORY)
- Bài 11: Add Assertion trong JMeter để kiểm tra kết quả mong đợi (THEORY)
- Bài 12: Thực hành: Xác định request phù hợp để thêm Response Assertion cho tình huống đăng nhập (EXERCISE)
- Bài 13: Tạo report và đọc thông số kiểm thử hiệu năng cơ bản trong JMeter (THEORY)
- Bài 14: Bài tập thực hành: Mô tả lại quy trình test hiệu năng một trang web bằng JMeter (EXERCISE)

#### Chương 8: Thiết kế test cho chức năng chuyển tiền ngân hàng

- Bài 1: Phân tích yêu cầu màn hình chuyển tiền và các thành phần dữ liệu (THEORY)
- Bài 2: Rule kiểm thử cho Ngân hàng, Số tài khoản và Họ tên chủ tài khoản (THEORY)
- Bài 3: Bài tập: Xác định điều kiện kiểm tra cho bộ trường thông tin người nhận (EXERCISE)
- Bài 4: Rule kiểm thử cho trường Số tiền và các giới hạn nghiệp vụ chuyển khoản (THEORY)
- Bài 5: Trắc nghiệm: Nhận diện đúng các rule của trường Số tiền (QUIZ)
- Bài 6: Rule kiểm thử cho Nội dung chuyển tiền, Lưu người thụ hưởng và Danh sách người nhận (THEORY)
- Bài 7: Bài tập: Phân tích hành vi lưu người thụ hưởng và cập nhật danh sách tối đa 100 người (EXERCISE)
- Bài 8: Rule kiểm thử cho nút Tiếp tục và trạng thái enable hoặc disable theo dữ liệu nhập (THEORY)
- Bài 9: Viết test case cho chức năng chuyển tiền ngân hàng từ yêu cầu đã cho (TESTCASE)

#### Chương 9: CV và ứng tuyển cho Tester

- Bài 1: CV Tester là gì và các tiêu chí nhà tuyển dụng thường đánh giá (THEORY)
- Bài 2: Những lỗi phổ biến khiến CV bị bỏ qua (THEORY)
- Bài 3: Quiz: Nhận diện nội dung nên có và không nên có trong CV Tester (QUIZ)
- Bài 4: Cấu trúc bắt buộc của CV Tester: thông tin cá nhân, học vấn, kinh nghiệm, kỹ năng và dự án (THEORY)
- Bài 5: Cách trình bày kinh nghiệm, kỹ năng và dự án theo định hướng Tester (THEORY)
- Bài 6: Bài tập: Rà soát một CV Tester và đề xuất chỉnh sửa để phù hợp hơn (EXERCISE)
- Bài 7: Viết email xin việc cho vị trí Tester: tiêu đề, nội dung và file đính kèm (THEORY)
- Bài 8: Bài tập: Soạn email ứng tuyển Tester ngắn gọn, rõ ràng và đúng định dạng (EXERCISE)
- Bài 9: Thái độ cơ bản khi đi phỏng vấn Tester (THEORY)

#### Chương 10: Bộ test case dùng chung cho ứng dụng web

- Bài 1: Tổng quan bộ test case dùng chung và cách đọc cấu trúc test case (THEORY)
- Bài 2: Nhóm test case xác thực tài khoản: đăng nhập, đăng xuất, quên mật khẩu (THEORY)
- Bài 3: Quiz: Nhận diện kết quả mong đợi đúng trong các tình huống đăng nhập và reset mật khẩu (QUIZ)
- Bài 4: Nhóm test case tìm kiếm và lọc dữ liệu với 1 trường và nhiều trường (THEORY)
- Bài 5: Bài tập: Phân tích các tình huống tìm kiếm rỗng, không tồn tại, trim khoảng trắng và không phân biệt hoa thường (EXERCISE)
- Bài 6: Nhóm test case nhập liệu và kiểm tra validation cho textbox, textarea, checkbox, radio, dropdown, date và file (THEORY)
- Bài 7: Viết test case cho form nhập liệu với các rule bắt buộc, độ dài, ký tự đặc biệt, XSS, SQL injection và upload file (TESTCASE)
- Bài 8: Nhóm test case CRUD, hiển thị dữ liệu, phân trang, import/export và quản lý dữ liệu (THEORY)
- Bài 9: Bài tập: Xác định test case phù hợp cho các tình huống trùng dữ liệu, xóa dữ liệu có ràng buộc và thay đổi số bản ghi trên trang (EXERCISE)
- Bài 10: Nhóm test case cho amount, định dạng tiền tệ, độ mạnh mật khẩu, popup xác nhận và phân quyền người dùng (THEORY)
- Bài 11: Quiz: Phân biệt test case chức năng, bảo mật, hiển thị và phân quyền trong bộ test case dùng chung (QUIZ)
- Bài 12: Bạn intern/fresher đang loay hoay viết testcase cho dự án? (THEORY, mở lẻ 100.000đ)

````

## Liên kết liên quan

- [Xem bản HTML](https://t5edu.site/courses)
- [Xem bản Markdown](https://t5edu.site/courses.md)
- [LLM index](https://t5edu.site/llms.txt)

Dữ liệu Markdown này được cache công khai và sẽ được làm mới sau các thay đổi nội dung/admin.