assert API

Trong phát triển phần mềm, assertion (sự xác nhận) được dùng để xác nhận một đoạn mã chạy chính xác, nếu không một ngoại lệ (lỗi) được tạo ra. Node.js hỗ trợ assertion nhờ module sẵn có là assert – ví dụ:

assert.equal(3 + 5, 8);

Lệnh này xác nhận rằng kết quả của 3 + 58. Nếu không một ngoại lệ được tạo ra.

Mô tả kết quả của đoạn mã thông qua assert

Trong ví dụ sau đây, assert biểu diễn kết quả kỳ vọng:

function id(x) {
  return x;
}
assert.equal(id('abc'), 'abc');

Chạy kiểm tra thông qua assert

Ví dụ sau là một đoạn mã giúp kiểm tra bạn viết hàm hello() có chính xác theo yêu cầu không:

test('First exercise', t => {
  assert.equal(hello('world'), 'Hello world!');
  assert.equal(hello('Jane'), 'Hello Jane!');
  assert.equal(hello('John'), 'Hello John!');
  assert.equal(hello(''), 'Hello !');
});

So sánh thông thường và so sánh sâu

Phương thức equal() sử dụng === để so sánh các giá trị. Theo đó một đối tượng chỉ bằng chính nó – thậm chí có một đối tượng khác có cùng nội dung (bởi vì === không so sánh nội dung của các đối tượng, chỉ so sánh tham chiếu):

assert.notEqual({foo: 1}, {foo: 1});

deepEqual() là lựa chọn tốt hơn để so sánh hai đối tượng:

assert.deepEqual({foo: 1}, {foo: 1});

Vì mảng cũng là đối tượng nên deepEqual() cũng hoạt động với mảng:

assert.notEqual(['a', 'b', 'c'], ['a', 'b', 'c']);
assert.deepEqual(['a', 'b', 'c'], ['a', 'b', 'c']);

Tham khảo nhanh

Phương thức assert.equal():

function equal(actual: any, expected: any, message?: string): void

actual === expected phải trả về true. Nếu không, ngoại lệ AssertionError được tạo ra.

assert.equal(3 + 3, 6);

Phương thức assert.notEqual():

function notEqual(actual: any, expected: any, message?: string): void

actual !== expected phải trả về true. Nếu không, lỗi AssertionError được tạo ra.

assert.notEqual(3 + 3, 22);

Tham số thứ ba, không bắt buộc có thể sử dụng để giải thích tại sao lại có ngoại lệ:

let e;
try {
  const x = 3;
  assert.equal(x, 8, 'x must be equal to 8')
} catch (err) {
  assert.equal(
    String(err),
    'AssertionError [ERR_ASSERTION]: x must be equal to 8');
}

Phương thức assert.deepEqual():

function deepEqual(actual: any, expected: any, message?: string): void

actual phải có nội dung giống expected. Nếu không lỗi AssertionError được tạo ra:

assert.deepEqual([1,2,3], [1,2,3]);
assert.deepEqual([], []);

Phương thức assert.notDeepEqual():

function notDeepEqual(actual: any, expected: any, message?: string): void

actual phải khác nội dung với expected. Nếu không lỗi AssertionError được tạo ra:

assert.notDeepEqual([1,2,3], [1,2]);

Xác nhận lỗi được tạo ra

Nếu bạn muốn (hay kỳ vọng) nhận được một ngoại lệ nào đó, bạn cần sử dụng phương thức throws() của assert. Hàm này chạy tham số đầu tiên của nó (là một hàm), và chỉ thành công nếu quá trình chạy hàm này tạo ra một ngoại lệ mong muốn. Các tham số bổ sung được dùng để chỉ rõ ngoại lệ phải có dạng thế nào.

Phiên bản 1: function throws(block: Function, message?: string): void:

assert.throws(
  () => {
    null.prop;
  }
);

Phiên bản 2: function throws(block: Function, error: Function, message?: string): void

assert.throws(
  () => {
    null.prop;
  },
  TypeError
);

Phiên bản 3: function throws(block: Function, error: RegExp, message?: string): void

assert.throws(
  () => {
    null.prop;
  },
  /^TypeError: Cannot read property 'prop' of null$/
);

Phiên bản 4: function throws(block: Function, error: Object, message?: string): void

assert.throws(
  () => {
    null.prop;
  },
  {
    name: 'TypeError',
    message: `Cannot read property 'prop' of null`,
  }
);

Một hàm công cụ khác

function fail(message: string | Error): never

Luôn tạo lỗi AssertionError khi được gọi. Thường dùng trong unit test:

try {
  functionThatShouldThrow();
  assert.fail();
} catch (_) {
  // Success
}