diff --git a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
index 4d0571b9d..46715d863 100644
--- a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
+++ b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/solution.md
@@ -1,49 +1,49 @@
-The test demonstrates one of the temptations a developer meets when writing tests.
+Bài kiểm tra thể hiện một trong những cám dỗ mà nhà phát triển gặp phải khi viết bài kiểm tra.
 
-What we have here is actually 3 tests, but layed out as a single function with 3 asserts.
+Những gì chúng ta có ở đây thực sự là 3 bài kiểm tra, nhưng được bố trí dưới dạng một hàm duy nhất với 3 lần xác nhận.
 
-Sometimes it's easier to write this way, but if an error occurs, it's much less obvious what went wrong.
+Đôi khi viết theo cách này dễ dàng hơn, nhưng nếu có lỗi xảy ra, thì sẽ khó nhận ra điều gì đã xảy ra.
 
-If an error happens in the middle of a complex execution flow, then we'll have to figure out the data at that point. We'll actually have to *debug the test*.
+Nếu xảy ra lỗi ở giữa quy trình thực thi phức tạp, thì chúng ta sẽ phải tìm ra dữ liệu tại thời điểm đó. Chúng ta thực sự sẽ phải *gỡ lỗi cho bài kiểm tra*.
 
-It would be much better to break the test into multiple `it` blocks with clearly written inputs and outputs.
+Sẽ tốt hơn nhiều nếu chia bài kiểm tra thành nhiều khối `it` với đầu vào và đầu ra được viết rõ ràng.
 
-Like this:
+Như thế này:
 ```js
-describe("Raises x to power n", function() {
-  it("5 in the power of 1 equals 5", function() {
+describe("Nâng x lên luỹ thừa n", function() {
+  it("5 mũ 1 bằng 5", function() {
     assert.equal(pow(5, 1), 5);
   });
 
-  it("5 in the power of 2 equals 25", function() {
+  it("5 mũ 2 bằng 25", function() {
     assert.equal(pow(5, 2), 25);
   });
 
-  it("5 in the power of 3 equals 125", function() {
+  it("5 mũ 3 bằng 125", function() {
     assert.equal(pow(5, 3), 125);
   });
 });
 ```
 
-We replaced the single `it` with `describe` and a group of `it` blocks. Now if something fails we would see clearly what the data was.
+Chúng ta đã thay thế một khối `it` bằng `describe` và một nhóm các khối `it`. Bây giờ nếu có gì đó không thành công, chúng ta sẽ thấy rõ ràng dữ liệu là gì.
 
-Also we can isolate a single test and run it in standalone mode by writing `it.only` instead of `it`:
+Ngoài ra, chúng ta có thể tách riêng một bài kiểm tra và chạy nó ở chế độ độc lập bằng cách viết `it.only` thay vì `it`:
 
 
 ```js
-describe("Raises x to power n", function() {
-  it("5 in the power of 1 equals 5", function() {
+describe("Nâng x lên luỹ thừa n", function() {
+  it("5 mũ 1 bằng 5", function() {
     assert.equal(pow(5, 1), 5);
   });
 
 *!*
-  // Mocha will run only this block
-  it.only("5 in the power of 2 equals 25", function() {
+  // Mocha sẽ chỉ chạy block này
+  it.only("5 mũ 2 bằng 25", function() {
     assert.equal(pow(5, 2), 25);
   });
 */!*
 
-  it("5 in the power of 3 equals 125", function() {
+  it("5 mũ 3 bằng 125", function() {
     assert.equal(pow(5, 3), 125);
   });
 });
diff --git a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md
index 66fece09a..d33e45f2b 100644
--- a/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md
+++ b/1-js/03-code-quality/05-testing-mocha/3-pow-test-wrong/task.md
@@ -2,12 +2,12 @@ importance: 5
 
 ---
 
-# What's wrong in the test?
+# Có gì sai trong bài kiểm tra?
 
-What's wrong in the test of `pow` below?
+Có gì sai trong bài kiểm tra `pow` bên dưới?
 
 ```js
-it("Raises x to the power n", function() {
+it("Nâng x lên luỹ thừa n", function() {
   let x = 5;
 
   let result = x;
@@ -21,4 +21,4 @@ it("Raises x to the power n", function() {
 });
 ```
 
-P.S. Syntactically the test is correct and passes.
+Tái bút: Về mặt cú pháp, bài kiểm tra là chính xác và đỗ.
diff --git a/1-js/03-code-quality/05-testing-mocha/article.md b/1-js/03-code-quality/05-testing-mocha/article.md
index 68ffcae4d..071f396ad 100644
--- a/1-js/03-code-quality/05-testing-mocha/article.md
+++ b/1-js/03-code-quality/05-testing-mocha/article.md
@@ -1,147 +1,147 @@
-# Automated testing with Mocha
+# Kiểm tra tự động với Mocha
 
-Automated testing will be used in further tasks, and it's also widely used in real projects.
+Kiểm tra tự động sẽ được sử dụng trong các tác vụ tiếp theo và nó cũng được sử dụng rộng rãi trong các dự án thực tế.
 
-## Why we need tests?
+## Tại sao chúng ta cần kiểm tra?
 
-When we write a function, we can usually imagine what it should do: which parameters give which results.
+Khi chúng ta viết một hàm, chúng ta thường có thể hình dung nó sẽ làm gì: tham số nào cho kết quả nào.
 
-During development, we can check the function by running it and comparing the outcome with the expected one. For instance, we can do it in the console.
+Trong quá trình phát triển, chúng ta có thể kiểm tra hàm bằng cách chạy nó và so sánh kết quả với kết quả mong đợi. Chẳng hạn, chúng ta có thể làm điều đó trong bảng điều khiển.
 
-If something is wrong -- then we fix the code, run again, check the result -- and so on till it works.
+Nếu có điều gì sai -- thì ta sửa mã, chạy lại, kiểm tra kết quả -- và cứ thế cho đến khi nó hoạt động.
 
-But such manual "re-runs" are imperfect.
+Nhưng "chạy lại" thủ công như vậy là không hoàn hảo.
 
-**When testing a code by manual re-runs, it's easy to miss something.**
+**Khi kiểm tra mã bằng cách chạy lại thủ công, rất dễ bỏ sót điều gì đó.**
 
-For instance, we're creating a function `f`. Wrote some code, testing: `f(1)` works, but `f(2)` doesn't work. We fix the code and now `f(2)` works. Looks complete? But we forgot to re-test `f(1)`. That may lead to an error.
+Chẳng hạn, chúng ta đang tạo một hàm `f`. Ta đã viết một số mã, thử nghiệm: `f(1)` hoạt động, nhưng `f(2)` không hoạt động. Chúng ta sửa mã và bây giờ `f(2)` hoạt động. Có vẻ hoàn chỉnh? Nhưng chúng ta đã quên kiểm tra lại `f(1)`. Điều đó có thể dẫn đến một lỗi.
 
-That's very typical. When we develop something, we keep a lot of possible use cases in mind. But it's hard to expect a programmer to check all of them manually after every change. So it becomes easy to fix one thing and break another one.
+Điều đó rất điển hình. Khi chúng ta phát triển một thứ gì đó, chúng ta ghi nhớ rất nhiều trường hợp sử dụng có thể xảy ra. Nhưng thật khó để mong đợi một lập trình viên kiểm tra tất cả chúng một cách thủ công sau mỗi lần thay đổi. Vì vậy, nó trở nên dễ dàng để sửa chữa một thứ và phá vỡ một thứ khác.
 
-**Automated testing means that tests are written separately, in addition to the code. They run our functions in various ways and compare results with the expected.**
+**Kiểm tra tự động có nghĩa là các kiểm tra được viết riêng, bên cạnh mã. Chúng chạy các hàm của chúng ta theo nhiều cách khác nhau và so sánh kết quả với kết quả mong đợi.**
 
 ## Behavior Driven Development (BDD)
 
-Let's start with a technique named [Behavior Driven Development](http://en.wikipedia.org/wiki/Behavior-driven_development) or, in short, BDD.
+Hãy bắt đầu với một kỹ thuật có tên [Behavior Driven Development](http://en.wikipedia.org/wiki/Behavior-driven_development) hoặc, ngắn gọn, BDD.
 
-**BDD is three things in one: tests AND documentation AND examples.**
+****BDD là ba thứ trong một: kiểm tra VÀ tài liệu VÀ ví dụ.**
 
-To understand BDD, we'll examine a practical case of development.
+Để hiểu BDD, chúng ta sẽ xem xét một trường hợp phát triển thực tế.
 
-## Development of "pow": the spec
+## Phát triển "pow": thông số kỹ thuật
 
-Let's say we want to make a function `pow(x, n)` that raises `x` to an integer power `n`. We assume that `n≥0`.
+Giả sử chúng ta muốn tạo một hàm `pow(x, n)` nâng `x` lên một lũy thừa nguyên `n`. Chúng ta giả định rằng `n≥0`.
 
-That task is just an example: there's the `**` operator in JavaScript that can do that, but here we concentrate on the development flow that can be applied to more complex tasks as well.
+Tác vụ đó chỉ là một ví dụ: có toán tử `**` trong JavaScript có thể làm điều đó, nhưng ở đây chúng ta tập trung vào quy trình phát triển cũng có thể được áp dụng cho các tác vụ phức tạp hơn.
 
-Before creating the code of `pow`, we can imagine what the function should do and describe it.
+Trước khi tạo mã của `pow`, chúng ta có thể hình dung chức năng này sẽ làm gì và mô tả nó.
 
-Such description is called a *specification* or, in short, a spec, and contains descriptions of use cases together with tests for them, like this:
+Mô tả như vậy được gọi là *thông số kỹ thuật* hay nói ngắn gọn là thông số và chứa mô tả về các trường hợp sử dụng cùng với các bài kiểm tra dành cho chúng, như sau:
 
 ```js
-describe("pow", function() {
+describe("luỹ thừa", function() {
 
-  it("raises to n-th power", function() {
+  it("nâng lên mũ n", function() {
     assert.equal(pow(2, 3), 8);
   });
 
 });
 ```
 
-A spec has three main building blocks that you can see above:
+Một thông số kỹ thuật có ba khối xây dựng chính mà bạn có thể thấy ở trên:
 
 `describe("title", function() { ... })`
-: What functionality we're describing. In our case we're describing the function `pow`. Used to group "workers" -- the `it` blocks.
+: Chúng ta đang mô tả hàm gì. Trong trường hợp của chúng ta, chúng ta đang mô tả hàm `pow`. Được sử dụng để nhóm "công nhân" -- các khối `it`.
 
 `it("use case description", function() { ... })`
-: In the title of `it` we *in a human-readable way* describe the particular use case, and the second argument is a function that tests it.
+: Trong tiêu đề của `it`, chúng ta *theo cách mà con người có thể đọc được* mô tả trường hợp sử dụng cụ thể và đối số thứ hai là một hàm kiểm tra trường hợp đó.
 
 `assert.equal(value1, value2)`
-: The code inside `it` block, if the implementation is correct, should execute without errors.
+: Mã bên trong khối `it`, nếu triển khai đúng, sẽ thực thi mà không có lỗi.
 
-    Functions `assert.*` are used to check whether `pow` works as expected. Right here we're using one of them -- `assert.equal`, it compares arguments and yields an error if they are not equal. Here it checks that the result of `pow(2, 3)` equals `8`. There are other types of comparisons and checks, that we'll add later.
+    Hàm `assert.*` được sử dụng để kiểm tra xem `pow` có hoạt động như mong đợi hay không. Ngay tại đây, chúng ta đang sử dụng một trong số chúng -- `assert.equal`, nó so sánh các đối số và đưa ra lỗi nếu chúng không bằng nhau. Tại đây, nó kiểm tra xem kết quả của `pow(2, 3)` có bằng `8` hay không. Có nhiều loại so sánh và kiểm tra khác mà chúng ta sẽ bổ sung sau.
 
-The specification can be executed, and it will run the test specified in `it` block. We'll see that later.
+Thông số kỹ thuật có thể được thực thi và nó sẽ chạy bài kiểm tra được chỉ định trong khối `it`. Chúng ta sẽ thấy điều đó sau.
 
-## The development flow
+## Dòng chảy phát triển
 
-The flow of development usually looks like this:
+Dòng phát triển thường trông như thế này:
 
-1. An initial spec is written, with tests for the most basic functionality.
-2. An initial implementation is created.
-3. To check whether it works, we run the testing framework [Mocha](http://mochajs.org/) (more details soon) that runs the spec. While the functionality is not complete, errors are displayed. We make corrections until everything works.
-4. Now we have a working initial implementation with tests.
-5. We add more use cases to the spec, probably not yet supported by the implementations. Tests start to fail.
-6. Go to 3, update the implementation till tests give no errors.
-7. Repeat steps 3-6 till the functionality is ready.
+1. Thông số kỹ thuật ban đầu được viết, với các bài kiểm tra hàm cơ bản nhất.
+2. Triển khai ban đầu được tạo.
+3. Để kiểm tra xem nó có hoạt động hay không, chúng ta chạy framework kiểm tra [Mocha](https://mochajs.org/) (sẽ sớm có thêm thông tin chi tiết) để chạy thông số kỹ thuật đó. Trong khi hàm không hoàn thành, lỗi được hiển thị. Chúng ta thực hiện chỉnh sửa cho đến khi mọi thứ hoạt động.
+4. Bây giờ chúng ta có một thực hiện ban đầu đang hoạt động với bài kiểm tra.
+5. Chúng ta thêm nhiều trường hợp sử dụng hơn vào thông số kỹ thuật, có thể chưa được triển khai hỗ trợ. Các thử nghiệm bắt đầu thất bại.
+6. Đến bước 3, cập nhật việc triển khai cho đến khi kiểm tra không có lỗi.
+7. Lặp lại các bước 3-6 cho đến khi hàm sẵn sàng.
 
-So, the development is *iterative*. We write the spec, implement it, make sure tests pass, then write more tests, make sure they work etc. At the end we have both a working implementation and tests for it.
+Vì vậy, sự phát triển là * lặp đi lặp lại *. Chúng ta viết thông số kỹ thuật, triển khai nó, đảm bảo nó vượt qua các bài kiểm tra, sau đó viết thêm các bài kiểm tra khác, đảm bảo chúng hoạt động, v.v. Cuối cùng, chúng ta vừa có một triển khai hoạt động và các bài kiểm tra cho nó.
 
-Let's see this development flow in our practical case.
+Hãy xem dòng phát triển này trong trường hợp thực tế của chúng ta.
 
-The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
+Bước đầu tiên đã hoàn tất: chúng ta có thông số kỹ thuật ban đầu cho `pow`. Bây giờ, trước khi thực hiện, hãy sử dụng một số thư viện JavaScript để chạy bài kiểm tra, chỉ để xem chúng có hoạt động không (tất cả chúng sẽ không thành công).
 
-## The spec in action
+## Thông số kỹ thuật hoạt động
 
-Here in the tutorial we'll be using the following JavaScript libraries for tests:
+Ở trong hướng dẫn này, chúng ta sẽ sử dụng các thư viện JavaScript sau để kiểm tra:
 
-- [Mocha](http://mochajs.org/) -- the core framework: it provides common testing functions including `describe` and `it` and the main function that runs tests.
-- [Chai](http://chaijs.com) -- the library with many assertions. It allows to use a lot of different assertions, for now we need only `assert.equal`.
-- [Sinon](http://sinonjs.org/) -- a library to spy over functions, emulate built-in functions and more, we'll need it much later.
+- [Mocha](http://mochajs.org/) -- framework cốt lõi: nó cung cấp các hàm kiểm tra phổ biến bao gồm `describe` và `it` và hàm chính chạy các bài kiểm tra.
+- [Chai](http://chaijs.com) -- thư viện có nhiều xác nhận. Nó cho phép sử dụng rất nhiều xác nhận khác nhau, bây giờ chúng ta chỉ cần `assert.equal`.
+- [Sinon](http://sinonjs.org/) -- một thư viện để theo dõi các hàm, mô phỏng các hàm tích hợp sẵn và hơn thế nữa, chúng ta sẽ cần đến nó sau này.
 
-These libraries are suitable for both in-browser and server-side testing. Here we'll consider the browser variant.
+Các thư viện này phù hợp cho cả kiểm tra trên trình duyệt và phía máy chủ. Ở đây chúng ta sẽ xem xét biến thể trình duyệt.
 
-The full HTML page with these frameworks and `pow` spec:
+Trang HTML đầy đủ với các khung này và thông số kỹ thuật `pow`:
 
 ```html src="index.html"
 ```
 
-The page can be divided into five parts:
+Trang này có thể được chia thành năm phần:
 
-1. The `<head>` -- add third-party libraries and styles for tests.
-2. The `<script>` with the function to test, in our case -- with the code for `pow`.
-3. The tests -- in our case an external script `test.js` that has `describe("pow", ...)` from above.
-4. The HTML element `<div id="mocha">` will be used by Mocha to output results.
-5. The tests are started by the command `mocha.run()`.
+1. `<head>` -- thêm các thư viện và kiểu của bên thứ ba cho các bài kiểm tra.
+2. `<script>` có hàm kiểm tra, trong trường hợp của chúng ta -- có mã cho `pow`.
+3. Các thử nghiệm -- trong trường hợp của chúng ta là một tập lệnh bên ngoài `test.js` có `describe("pow", ...)` ở phía trên.
+4. Phần tử HTML `<div id="mocha">` sẽ được Mocha sử dụng để xuất kết quả.
+5. Các bài kiểm tra được bắt đầu bằng lệnh `mocha.run()`.
 
-The result:
+Kết quả:
 
 [iframe height=250 src="pow-1" border=1 edit]
 
-As of now, the test fails, there's an error. That's logical: we have an empty function code in `pow`, so `pow(2,3)` returns `undefined` instead of `8`.
+Hiện tại, thử nghiệm không thành công, có lỗi. Điều đó hợp lý: chúng ta có một mã hàm trống trong `pow`, vì vậy `pow(2,3)` trả về `undefined` thay vì `8`.
 
-For the future, let's note that there are more high-level test-runners, like [karma](https://karma-runner.github.io/) and others, that make it easy to autorun many different tests.
+Trong tương lai, hãy lưu ý rằng có nhiều trình chạy kiểm tra cấp cao hơn, như [karma](https://karma-runner.github.io/) và những trình chạy kiểm tra khác, giúp dễ dàng tự động chạy nhiều bài kiểm tra khác nhau.
 
-## Initial implementation
+## Thực hiện ban đầu
 
-Let's make a simple implementation of `pow`, for tests to pass:
+Hãy thực hiện một triển khai đơn giản của `pow` để vượt qua các bài kiểm tra:
 
 ```js
 function pow(x, n) {
-  return 8; // :) we cheat!
+  return 8; // :) chúng ta gian lận!
 }
 ```
 
-Wow, now it works!
+Chà, bây giờ nó hoạt động!
 
 [iframe height=250 src="pow-min" border=1 edit]
 
-## Improving the spec
+## Cải thiện thông số kỹ thuật
 
-What we've done is definitely a cheat. The function does not work: an attempt to calculate `pow(3,4)` would give an incorrect result, but tests pass.
+Những gì chúng ta đã làm chắc chắn là gian lận. Hàm này không hoạt động: một nỗ lực tính toán `pow(3,4)` sẽ cho kết quả không chính xác, nhưng các phép kiểm tra đã vượt qua.
 
-...But the situation is quite typical, it happens in practice. Tests pass, but the function works wrong. Our spec is imperfect. We need to add more use cases to it.
+...Nhưng tình huống khá điển hình, nó xảy ra trong thực tế. Nó vượt qua các bài kiểm tra, nhưng hàm hoạt động sai. Thông số kỹ thuật của chúng ta là không hoàn hảo. Chúng ta cần thêm nhiều trường hợp sử dụng hơn cho nó.
 
-Let's add one more test to check that `pow(3, 4) = 81`.
+Hãy thêm một phép thử nữa để kiểm tra xem `pow(3, 4) = 81`.
 
-We can select one of two ways to organize the test here:
+Chúng ta có thể lựa chọn một trong hai cách tổ chức kiểm tra tại đây:
 
-1. The first variant -- add one more `assert` into the same `it`:
+1. Biến thể đầu tiên -- thêm một `assert` nữa vào cùng `it`:
 
     ```js
-    describe("pow", function() {
+    describe("luỹ thừa", function() {
 
-      it("raises to n-th power", function() {
+      it("nâng lên mũ n", function() {
         assert.equal(pow(2, 3), 8);
     *!*
         assert.equal(pow(3, 4), 81);
@@ -150,43 +150,43 @@ We can select one of two ways to organize the test here:
 
     });
     ```
-2. The second -- make two tests:
+2. Thứ hai -- thực hiện hai bài kiểm tra:
 
     ```js
-    describe("pow", function() {
+    describe("luỹ thừa", function() {
 
-      it("2 raised to power 3 is 8", function() {
+      it("2 mũ 3 là 8", function() {
         assert.equal(pow(2, 3), 8);
       });
 
-      it("3 raised to power 4 is 81", function() {
+      it("3 mũ 4 là 81", function() {
         assert.equal(pow(3, 4), 81);
       });
 
     });
     ```
 
-The principal difference is that when `assert` triggers an error, the `it` block immediately terminates. So, in the first variant if the first `assert` fails, then we'll never see the result of the second `assert`.
+Sự khác biệt chính là khi `assert` gây ra lỗi, khối `it` sẽ ngay lập tức chấm dứt. Vì vậy, trong biến thể đầu tiên nếu `assert` đầu tiên không thành công, thì chúng ta sẽ không bao giờ thấy kết quả của `assert` thứ hai.
 
-Making tests separate is useful to get more information about what's going on, so the second variant is better.
+Thực hiện các bài kiểm tra riêng biệt rất hữu ích để có thêm thông tin về những gì đang diễn ra, vì vậy biến thể thứ hai sẽ tốt hơn.
 
-And besides that, there's one more rule that's good to follow.
+Và bên cạnh đó, có một quy tắc nữa rất tốt để tuân theo.
 
-**One test checks one thing.**
+**Mỗi bài kiểm tra chỉ kiểm tra một thứ.**
 
-If we look at the test and see two independent checks in it, it's better to split it into two simpler ones.
+Nếu chúng ta nhìn vào bài kiểm tra và thấy có hai lần kiểm tra độc lập trong đó, thì tốt hơn là chia nó thành hai lần kiểm tra đơn giản hơn.
 
-So let's continue with the second variant.
+Vì vậy, hãy tiếp tục với biến thể thứ hai.
 
-The result:
+Kết quả:
 
 [iframe height=250 src="pow-2" edit border="1"]
 
-As we could expect, the second test failed. Sure, our function always returns `8`, while the `assert` expects `81`.
+Như chúng ta có thể mong đợi, bài kiểm tra thứ hai đã thất bại. Chắc chắn rồi, hàm của chúng ta luôn trả về `8`, trong khi `assert` mong đợi `81`.
 
-## Improving the implementation
+## Cải thiện việc thực hiện
 
-Let's write something more real for tests to pass:
+Hãy viết một cái gì đó thực tế hơn để vượt qua các bài kiểm tra:
 
 ```js
 function pow(x, n) {
@@ -200,14 +200,14 @@ function pow(x, n) {
 }
 ```
 
-To be sure that the function works well, let's test it for more values. Instead of writing `it` blocks manually, we can generate them in `for`:
+Để chắc chắn rằng hàm hoạt động tốt, hãy kiểm tra nó để biết thêm giá trị. Thay vì viết các khối `it` theo cách thủ công, chúng ta có thể tạo chúng trong `for`:
 
 ```js
-describe("pow", function() {
+describe("luỹ thừa", function() {
 
   function makeTest(x) {
     let expected = x * x * x;
-    it(`${x} in the power 3 is ${expected}`, function() {
+    it(`${x} mũ 3 là ${expected}`, function() {
       assert.equal(pow(x, 3), expected);
     });
   }
@@ -219,26 +219,26 @@ describe("pow", function() {
 });
 ```
 
-The result:
+Kết quả:
 
 [iframe height=250 src="pow-3" edit border="1"]
 
-## Nested describe
+## Mô tả lồng nhau
 
-We're going to add even more tests. But before that let's note that the helper function `makeTest` and `for` should be grouped together. We won't need `makeTest` in other tests, it's needed only in `for`: their common task is to check how `pow` raises into the given power.
+Chúng ta sẽ thêm nhiều bài kiểm tra hơn nữa. Nhưng trước đó, hãy lưu ý rằng hàm trợ giúp `makeTest` và `for` nên được nhóm lại với nhau. Chúng ta sẽ không cần `makeTest` trong các bài kiểm tra khác, nó chỉ cần trong `for`: nhiệm vụ chung của chúng là kiểm tra xem `pow` tăng lên như thế nào với công suất nhất định.
 
-Grouping is done with a nested `describe`:
+Việc nhóm lại được thực hiện với một `describe` lồng nhau:
 
 ```js
-describe("pow", function() {
+describe("luỹ thừa", function() {
 
 *!*
-  describe("raises x to power 3", function() {
+  describe("nâng x lên mũ 3", function() {
 */!*
 
     function makeTest(x) {
       let expected = x * x * x;
-      it(`${x} in the power 3 is ${expected}`, function() {
+      it(`${x} lũy thừa 3 là ${expected}`, function() {
         assert.equal(pow(x, 3), expected);
       });
     }
@@ -251,76 +251,76 @@ describe("pow", function() {
   });
 */!*
 
-  // ... more tests to follow here, both describe and it can be added
+  // ... nhiều bài kiểm tra để tiếp theo ở đây, cả describe và it có thể được thêm vào
 });
 ```
 
-The nested `describe` defines a new "subgroup" of tests. In the output we can see the titled indentation:
+`describe` lồng nhau xác định một "nhóm con" mới của các bài kiểm tra. Trong đầu ra, chúng ta có thể thấy thụt đầu dòng có tiêu đề:
 
 [iframe height=250 src="pow-4" edit border="1"]
 
-In the future we can add more `it` and `describe` on the top level with helper functions of their own, they won't see `makeTest`.
+Trong tương lai, chúng ta có thể thêm nhiều `it` và `describe` ở cấp cao nhất với các hàm trợ giúp của riêng chúng, chúng sẽ không thấy `makeTest`.
 
-````smart header="`before/after` and `beforeEach/afterEach`"
-We can setup `before/after` functions that execute before/after running tests, and also `beforeEach/afterEach` functions that execute before/after *every* `it`.
+````smart header="`before/after` và `beforeEach/afterEach`"
+Chúng ta có thể thiết lập các hàm `before/after` để thực thi trước/sau khi chạy các bài kiểm tra, cũng như các hàm `beforeEach/afterEach` để thực thi trước/sau *mọi* `it`.
 
-For instance:
+Ví dụ:
 
 ```js no-beautify
-describe("test", function() {
+describe("kiểm tra", function() {
 
-  before(() => alert("Testing started – before all tests"));
-  after(() => alert("Testing finished – after all tests"));
+  before(() => alert("Bài kiểm tra bắt đầu – trước tất cả các bài kiểm tra"));
+  after(() => alert("Bài kiểm tra kết thúc – sau tất cả các bài kiểm tra"));
 
-  beforeEach(() => alert("Before a test – enter a test"));
-  afterEach(() => alert("After a test – exit a test"));
+  beforeEach(() => alert("Trước khi kiểm tra – nhập một bài kiểm tra"));
+  afterEach(() => alert("Sau khi kiểm tra – xóa một bài kiểm tra"));
 
-  it('test 1', () => alert(1));
-  it('test 2', () => alert(2));
+  it('bài kiểm tra 1', () => alert(1));
+  it('bài kiểm tra 2', () => alert(2));
 
 });
 ```
 
-The running sequence will be:
+Trình tự chạy sẽ là:
 
 ```
-Testing started – before all tests (before)
-Before a test – enter a test (beforeEach)
+Bài kiểm tra đã bắt đầu – trước tất cả các bài kiểm tra (before)
+Trước khi kiểm tra – nhập một bài kiểm tra (beforeEach)
 1
-After a test – exit a test   (afterEach)
-Before a test – enter a test (beforeEach)
+Sau khi kiểm tra – thoát khỏi kiểm tra (afterEach)
+Trước khi kiểm tra – nhập một bài kiểm tra (beforeEach)
 2
-After a test – exit a test   (afterEach)
-Testing finished – after all tests (after)
+Sau khi kiểm tra – thoát khỏi kiểm tra (afterEach)
+Bài kiểm tra kết thúc – sau tất cả các bài kiểm tra (after)
 ```
 
 [edit src="beforeafter" title="Open the example in the sandbox."]
 
-Usually, `beforeEach/afterEach` and `before/after` are used to perform initialization, zero out counters or do something else between the tests (or test groups).
+Thông thường, `beforeEach/afterEach` và `before/after` được sử dụng để thực hiện khởi tạo, bộ đếm loại bỏ hoặc làm điều gì đó khác giữa các bài kiểm tra (hoặc nhóm kiểm tra).
 ````
 
-## Extending the spec
+## Mở rộng thông số kỹ thuật
 
-The basic functionality of `pow` is complete. The first iteration of the development is done. When we're done celebrating and drinking champagne -- let's go on and improve it.
+Chức năng cơ bản của `pow` đã hoàn tất. Sự lặp lại đầu tiên của sự phát triển được thực hiện. Khi chúng ta đã ăn mừng và uống rượu sâm panh xong -- hãy tiếp tục và cải thiện nó.
 
-As it was said, the function `pow(x, n)` is meant to work with positive integer values `n`.
+Như đã nói, hàm `pow(x, n)` có nghĩa là hoạt động với các giá trị nguyên dương `n`.
 
-To indicate a mathematical error, JavaScript functions usually return `NaN`. Let's do the same for invalid values of `n`.
+Để chỉ ra một lỗi toán học, các hàm JavaScript thường trả về `NaN`. Hãy làm tương tự cho các giá trị không hợp lệ của `n`.
 
-Let's first add the behavior to the spec(!):
+Trước tiên hãy thêm hành vi vào thông số kỹ thuật (!):
 
 ```js
-describe("pow", function() {
+describe("luỹ thừa", function() {
 
   // ...
 
-  it("for negative n the result is NaN", function() {
+  it("đối với n âm, kết quả là NaN", function() {
 *!*
     assert.isNaN(pow(2, -1));
 */!*
   });
 
-  it("for non-integer n the result is NaN", function() {
+  it("đối với n không nguyên, kết quả là NaN", function() {
 *!*
     assert.isNaN(pow(2, 1.5));    
 */!*
@@ -329,32 +329,32 @@ describe("pow", function() {
 });
 ```
 
-The result with new tests:
+Kết quả với các bài kiểm tra mới:
 
 [iframe height=530 src="pow-nan" edit border="1"]
 
-The newly added tests fail, because our implementation does not support them. That's how BDD is done: first we write failing tests, and then make an implementation for them.
+Các bài kiểm tra mới được thêm vào không thành công vì quá trình triển khai của chúng ta không hỗ trợ chúng. Đó là cách BDD được thực hiện: đầu tiên chúng ta viết các bài kiểm tra không thành công, sau đó thực hiện triển khai cho chúng.
 
-```smart header="Other assertions"
-Please note the assertion `assert.isNaN`: it checks for `NaN`.
+```smart header="Các khẳng định khác"
+Hãy lưu ý xác nhận `assert.isNaN`: nó kiểm tra `NaN`.
 
-There are other assertions in [Chai](http://chaijs.com) as well, for instance:
+Chẳng hạn, có các xác nhận khác trong [Chai](http://chaijs.com):
 
-- `assert.equal(value1, value2)` -- checks the equality  `value1 == value2`.
-- `assert.strictEqual(value1, value2)` -- checks the strict equality `value1 === value2`.
-- `assert.notEqual`, `assert.notStrictEqual` -- inverse checks to the ones above.
-- `assert.isTrue(value)` -- checks that `value === true`
-- `assert.isFalse(value)` -- checks that `value === false`
-- ...the full list is in the [docs](http://chaijs.com/api/assert/)
+- `assert.equal(value1, value2)` -- kiểm tra đẳng thức `value1 == value2`.
+- `assert.strictEqual(value1, value2)` -- kiểm tra sự bằng nhau nghiêm ngặt `value1 === value2`.
+- `assert.notEqual`, `assert.notStrictEqual` -- kiểm tra nghịch đảo các kiểm tra ở trên.
+- `assert.isTrue(value)` -- kiểm tra xem `value === true`
+- `assert.isFalse(value)` -- kiểm tra xem `value === false`
+- ...danh sách đầy đủ có trong [tài liệu](http://chaijs.com/api/assert/)
 ```
 
-So we should add a couple of lines to `pow`:
+Vì vậy, chúng ta nên thêm một vài dòng vào `pow`:
 
 ```js
 function pow(x, n) {
 *!*
-  if (n < 0) return NaN;
-  if (Math.round(n) != n) return NaN;
+  nếu (n < 0) trả về NaN;
+  nếu (Math.round(n) != n) trả về NaN;
 */!*
 
   let result = 1;
@@ -367,43 +367,43 @@ function pow(x, n) {
 }
 ```
 
-Now it works, all tests pass:
+Bây giờ nó hoạt động, đều vượt qua tất cả các bài kiểm tra:
 
 [iframe height=300 src="pow-full" edit border="1"]
 
-[edit src="pow-full" title="Open the full final example in the sandbox."]
+[edit src="pow-full" title="Mở toàn bộ ví dụ cuối cùng trong sandbox."]
 
-## Summary
+## Tóm tắt
 
-In BDD, the spec goes first, followed by implementation. At the end we have both the spec and the code.
+Trong BDD, thông số kỹ thuật đi trước, tiếp theo là triển khai. Cuối cùng, chúng ta vừa có thông số kỹ thuật và mã.
 
-The spec can be used in three ways:
+Thông số kỹ thuật có thể được sử dụng theo ba cách:
 
-1. As **Tests** - they guarantee that the code works correctly.
-2. As **Docs** -- the titles of `describe` and `it` tell what the function does.
-3. As **Examples** -- the tests are actually working examples showing how a function can be used.
+1. Như **Bài kiểm tra** - họ đảm bảo rằng mã hoạt động chính xác.
+2. Như **Tài liệu** -- tiêu đề của `describe` và `it` cho biết hàm này làm gì.
+3. Như **Ví dụ** -- các bài kiểm tra thực sự là các ví dụ hoạt động cho thấy cách sử dụng một hàm.
 
-With the spec, we can safely improve, change, even rewrite the function from scratch and make sure it still works right.
+Với thông số kỹ thuật, chúng ta có thể cải thiện, thay đổi, thậm chí viết lại hàm từ đầu một cách an toàn và đảm bảo rằng nó vẫn hoạt động bình thường.
 
-That's especially important in large projects when a function is used in many places. When we change such a function, there's just no way to manually check if every place that uses it still works right.
+Điều đó đặc biệt quan trọng trong các dự án lớn khi một hàm được sử dụng ở nhiều nơi. Khi chúng ta thay đổi một hàm như vậy, không có cách nào để kiểm tra thủ công xem mọi nơi sử dụng hàm đó có còn hoạt động bình thường hay không.
 
-Without tests, people have two ways:
+Nếu không có bài kiểm tra, mọi người có hai cách:
 
-1. To perform the change, no matter what. And then our users meet bugs, as we probably fail to check something manually.
-2. Or, if the punishment for errors is harsh, as there are no tests, people become afraid to modify such functions, and then the code becomes outdated, no one wants to get into it. Not good for development.
+1. Để thực hiện thay đổi, không có vấn đề gì. Và sau đó, người dùng của chúng ta gặp lỗi, vì chúng ta có thể không kiểm tra thứ gì đó theo cách thủ công.
+2. Hoặc, nếu hình phạt cho các lỗi là khắc nghiệt, vì không có kiểm tra, mọi người trở nên ngại sửa đổi các hàm đó, và sau đó mã trở nên lỗi thời, không ai muốn nhúng tay vào. không tốt cho sự phát triển.
 
-**Automatic testing helps to avoid these problems!**
+**Kiểm tra tự động giúp tránh những vấn đề này!**
 
-If the project is covered with tests, there's just no such problem. After any changes, we can run tests and see a lot of checks made in a matter of seconds.
+Nếu dự án được bao phủ bởi các bài kiểm tra, thì sẽ không có vấn đề như vậy. Sau bất kỳ thay đổi nào, chúng ta có thể chạy bài kiểm tra và thấy rất nhiều kiểm tra được thực hiện chỉ trong vài giây.
 
-**Besides, a well-tested code has better architecture.**
+**Bên cạnh đó, mã được kiểm tra tốt sẽ có kiến trúc tốt hơn.**
 
-Naturally, that's because auto-tested code is easier to modify and improve. But there's also another reason.
+Đương nhiên, đó là vì mã được kiểm tra tự động dễ sửa đổi và cải thiện hơn. Nhưng cũng có một lý do khác.
 
-To write tests, the code should be organized in such a way that every function has a clearly described task, well-defined input and output. That means a good architecture from the beginning.
+Để viết các bài kiểm tra, mã phải được tổ chức theo cách sao cho mọi hàm đều có nhiệm vụ được mô tả rõ ràng, đầu vào và đầu ra được xác định rõ ràng. Điều đó có nghĩa là một kiến trúc tốt ngay từ đầu.
 
-In real life that's sometimes not that easy. Sometimes it's difficult to write a spec before the actual code, because it's not yet clear how it should behave. But in general writing tests makes development faster and more stable.
+Trong cuộc sống thực đôi khi không dễ dàng như vậy. Đôi khi rất khó để viết một thông số kỹ thuật trước mã thực tế, vì vẫn chưa rõ nó sẽ hoạt động như thế nào. Nhưng nói chung, các bài kiểm tra viết giúp phát triển nhanh hơn và ổn định hơn.
 
-Later in the tutorial you will meet many tasks with tests baked-in. So you'll see more practical examples.
+Ở phần sau của hướng dẫn, bạn sẽ gặp nhiều nhiệm vụ với các bài kiểm tra được tích hợp sẵn. Vì vậy, bạn sẽ thấy nhiều ví dụ thực tế hơn.
 
-Writing tests requires good JavaScript knowledge. But we're just starting to learn it. So, to settle down everything, as of now you're not required to write tests, but you should already be able to read them even if they are a little bit more complex than in this chapter.
+Viết bài kiểm tra yêu cầu kiến thức JavaScript tốt. Nhưng chúng ta chỉ mới bắt đầu tìm hiểu nó. Vì vậy, để ổn định mọi thứ, hiện tại bạn không bắt buộc phải viết các bài kiểm tra, nhưng bạn đã có thể đọc chúng ngay cả khi chúng phức tạp hơn một chút so với trong chương này.
diff --git a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html
index e680b536b..1f8e175e2 100644
--- a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/index.html
@@ -1,31 +1,31 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật kiểm tra kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
 
 <body>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js
index d3de82546..d4df8ad5f 100644
--- a/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/beforeafter.view/test.js
@@ -1,16 +1,16 @@
 describe("test", function() {
   
-   // Mocha usually waits for the tests for 2 seconds before considering them wrong
+   // Mocha thường đợi các bài kiểm tra trong 2 giây trước khi coi chúng sai
   
-  this.timeout(200000); // With this code we increase this - in this case to 200,000 milliseconds
+  this.timeout(200000); // Với mã này, chúng ta tăng cái này (timeout) - trong trường hợp này là 200.000 mili giây
 
-  // This is because of the "alert" function, because if you delay pressing the "OK" button the tests will not pass!
+  // Điều này là do hàm "alert", bởi vì nếu bạn trì hoãn nhấn nút "OK" thì các bài kiểm tra sẽ không vượt qua!
   
-  before(() => alert("Testing started – before all tests"));
-  after(() => alert("Testing finished – after all tests"));
+  before(() => alert("Bài kiểm tra bắt đầu – trước tất cả các bài kiểm tra"));
+  after(() => alert("Bài kiểm tra kết thúc – sau tất cả các bài kiểm tra"));
 
-  beforeEach(() => alert("Before a test – enter a test"));
-  afterEach(() => alert("After a test – exit a test"));
+  beforeEach(() => alert("Trước một bài kiểm tra – nhập một bài kiểm tra"));
+  afterEach(() => alert("Trước một bài kiểm tra – nhập một bài kiểm tra"));
 
   it('test 1', () => alert(1));
   it('test 2', () => alert(2));
diff --git a/1-js/03-code-quality/05-testing-mocha/index.html b/1-js/03-code-quality/05-testing-mocha/index.html
index 28a2ea62b..1d3610777 100644
--- a/1-js/03-code-quality/05-testing-mocha/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/index.html
@@ -1,17 +1,17 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    mocha.setup('bdd'); // minimal setup
+    mocha.setup('bdd'); // thiết lập tối thiểu
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -20,17 +20,17 @@
 
   <script>
     function pow(x, n) {
-      /* function code is to be written, empty now */
+      /* mã hàm sẽ được viết, bây giờ đang trống */
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html
index e48a8d3a2..4b549f474 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-1.view/index.html
@@ -1,18 +1,18 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật kiểm tra kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -21,17 +21,17 @@
 
   <script>
     function pow(x, n) {
-      /* function code is to be written, empty now */
+      /* mã hàm sẽ được viết, bây giờ đang trống */
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
index e8d6be23d..8ec3889e2 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-2.view/index.html
@@ -1,18 +1,18 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật kiểm tra kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -21,17 +21,17 @@
 
   <script>
     function pow(x, n) {
-      return 8; // :) we cheat!
+      return 8; // :) chúng ta gian lận!
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html
index c71b0d5d5..5596b92cd 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-3.view/index.html
@@ -1,18 +1,18 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật kiểm tra kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -31,13 +31,13 @@
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html
index c71b0d5d5..5596b92cd 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-4.view/index.html
@@ -1,18 +1,18 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật kiểm tra kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -31,13 +31,13 @@
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js b/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js
index e5ce2ce43..dc8660071 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js
+++ b/1-js/03-code-quality/05-testing-mocha/pow-4.view/test.js
@@ -15,5 +15,5 @@ describe("pow", function() {
 
   });
 
-  // ... more tests to follow here, both describe and it can be added
+  // ... nhiều bài kiểm tra để theo dõi ở đây, cả describe và it có thể được thêm vào
 });
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html
index 076b1e5a9..43e362214 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-full.view/index.html
@@ -1,18 +1,18 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật kiểm tra kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -32,13 +32,13 @@
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html
index d82a79dca..d5514e388 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-min.view/index.html
@@ -1,18 +1,18 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật thử nghiệm kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -21,17 +21,17 @@
 
   <script>
     function pow() {
-      return 8; // :) we cheat!
+      return 8; // :) chúng ta gian lận!
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>
diff --git a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html
index 523ae25ec..ac3b8327a 100644
--- a/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html
+++ b/1-js/03-code-quality/05-testing-mocha/pow-nan.view/index.html
@@ -1,18 +1,18 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <!-- add mocha css, to show results -->
+  <!-- thêm mocha css, để hiển thị kết quả -->
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.css">
-  <!-- add mocha framework code -->
+  <!-- thêm mã mocha framework -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/3.2.0/mocha.js"></script>
   <script>
-    // enable bdd-style testing
+    // bật kiểm tra kiểu bdd
     mocha.setup('bdd');
   </script>
-  <!-- add chai -->
+  <!-- thêm chai -->
   <script src="https://cdnjs.cloudflare.com/ajax/libs/chai/3.5.0/chai.js"></script>
   <script>
-    // chai has a lot of stuff, let's make assert global
+    // chai có rất nhiều thứ, hãy xác nhận chung
     let assert = chai.assert;
   </script>
 </head>
@@ -29,13 +29,13 @@
     }
   </script>
 
-  <!-- the script with tests (describe, it...) -->
+  <!-- tập lệnh với các bài kiểm tra (describe, it...) -->
   <script src="test.js"></script>
 
-  <!-- the element with id="mocha" will contain test results -->
+  <!-- phần tử có id="mocha" sẽ chứa kết quả kiểm tra -->
   <div id="mocha"></div>
 
-  <!-- run tests! -->
+  <!-- chạy các bài kiểm tra! -->
   <script>
     mocha.run();
   </script>