断言库（检查点函数）

  1. 严格判断关键字strict {#strict}
  2. 断言库提供的方法

断言库 assert 是Node.js和Python中内置的库之一，其主要用途是在自动化测试脚本中添加检查点。这些检查点是用来验证被测试的应用或者系统是否满足某种特定的条件，如果条件不满足，断言库会抛出错误，从而让我们知道脚本在何处出现了问题。

在Node.js中，我们可以通过以下方式引入assert库：

JavaScript
const assert = require('assert');
而在Python中，assert是内置的，无需单独引入。

在CukeTest的环境中，我们甚至可以直接从工具箱中拖拽assert到脚本编辑器中，自动生成对应的脚本代码。

值得一提的是，CukeTest还提供了checkProperty()方法，它是一种更便捷的方式，专门用于检查测试对象的属性是否符合预期值。这在很多场景下可以作为assert的替代或者补充，使得检查点的设置更加灵活和高效。

严格判断关键字strict

对于所有带equal关键字的方法，如equal()、deepEqual()、notEqual()、notDeepEqual()等，都可以将equal改为strictEqual来进行严格判断，如改为strictEqual()、deepstrictEqual()、notstrictEqual()、notDeepstrictEqual()。

默认使用的是抽象（非严格）判断，加上strict关键字可以改为严格判断，概括来说，如果不计划学习JavaScript语言中类型之间的关系，那么全部使用strict关键字可以保证检验结果足够可靠。二者的区别即==判断与===判断的区别。在体现在脚本中的关系如下：

严格相等

JavaScript
let num = 0;
let obj = new String("0");
let str = "0";
let b = false;

console.log(num === num); // true
console.log(obj === obj); // true
console.log(str === str); // true

console.log(num === obj); // false
console.log(num === str); // false
console.log(obj === str); // false
console.log(null === undefined); // false
console.log(obj === null); // false
console.log(obj === undefined); // false

抽象相等

JavaScript
let num = 0;
let obj = new String("0");
let str = "0";
let b = false;

console.log(num == num); // true
console.log(obj == obj); // true
console.log(str == str); // true

console.log(num == obj); // true
console.log(num == str); // true
console.log(obj == str); // true
console.log(null == undefined); // true

// both false, except in rare cases
console.log(obj == null);
console.log(obj == undefined);

断言库提供的方法

assert(value: any, message?: string|Error)

判断传入的参数是否为真，否则抛出错误信息。

  • value: 任意类型，检查是否为真的输入，因此可以传入一个表达式，如assert(a===b, 'a not equal to b')。
  • message: string或Error类型。

assert.ok()的简易用法。

assert.ok(value: any, message?: string|Error)

  • value: 任意类型，检查是否为真的输入，因此可以传入一个表达式，如assert.ok(a===b, 'a not equal to b')。
  • message: string或Error类型。

assert.equal(actual, expected: any, message?: string|Error)

用于判断预期值与实际值是否相等。相等关系等效于抽象相等==运算符。如果加上strict关键字，改为调用assert.strictEqual()，则等效与严格相等 ===运算符。

  • actual: 任意类型，
  • expected: 任意类型，
  • message: string或Error类型。

JavaScript
const assert = require('assert');

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'
assert.equal(NaN, NaN);
// OK

assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

assert.deepEqual(actual, expected: any, message?: string|Error)

用于判断预期值与实际值是否深度相等，通常用于判断两个对象是否从外部到内部属性都完全一致。由于判断对象相等的开销问题，JavaScript中的对象判断只会判断对象的来源（内存位置，或理解为指针）是否一致。

  • actual: 任意类型，
  • expected: 任意类型，
  • message: string或Error类型

对于对象判断来说，只要来个对象来源不一致，即使是两个空对象也是不相等的：

JavaScript
let a = {};
let b = {};
console.log(a == b); // false
b = a; // 将b指向a的内存地址
console.log(a == b); // true

深度比较详情

“深度”相等意味着还会比较子对象的可枚举“自有”属性：

JavaScript
const assert = require('assert');

const obj1 = {
  a: {
    b: 1
  }
};
const obj2 = {
  a: {
    b: 2
  }
};
const obj3 = {
  a: {
    b: 1
  }
};
// 以obj1的类构造新实例，这里为空对象{}
const obj4 = Object.create(obj1); 

assert.deepEqual(obj1, obj1);
// OK

// b 的值不同：
assert.deepEqual(obj1, obj2);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3);
// OK

// 类型一致也不行：
assert.deepEqual(obj1, obj4);
// 抛出 AssertionError: { a: { b: 1 } } deepEqual {}

如果值不相等，则抛出 [AssertionError]，并将 message 属性设置为等于 message 参数的值。 如果未定义 message 参数，则会分配默认错误消息。 如果 message 参数是 [Error] 的实例，那么它将被抛出而不是 [AssertionError]。

assert.notEqual(actual, expected: any, message?: string|Error)

用于判断预期值与实际值是否不相等。相等关系等效于抽象不相等!=运算符。如果加上strict关键字，改为调用assert.notStrictEqual()，则等效与严格不相等 !==运算符。

  • actual: 任意类型，
  • expected: 任意类型，
  • message: string或Error类型。

assert.notDeepEqual(actual, expected: any, message?: string|Error)

用于判断预期值与实际值是否深度不相等，通常用于判断两个对象从外部到内部属性是否存在不一致。

  • actual: 任意类型，
  • expected: 任意类型，
  • message: string或Error类型

results matching ""

全部 API Walkthrough 其他

    No results matching ""