使用Assert模块来验证Node.js中的不变式

2020年12月30日11:21:43 发表评论 34 次浏览

本文概述

的断言模块inNode.js用于测试Node.js应用程序中功能的表达式。如果测试结果返回false, 则assert会引发错误并停止程序。你可以将断言模块与单元测试工具一起使用, 例如单位, 摩卡咖啡和hai.

开发人员使用assert来测试其应用程序中的不变性。但是什么是不变式, 有什么不同的方法来验证它们呢?

什么是不变式?

不变式是需要在程序中的某个点返回true的表达式或条件。让我们仔细看看下面的表达式:

let a = 5;
let b = 3;
let correct = (a > b);
console.log (correct);

在终端或Bash上运行时, 它应该返回" true"。如果由于某种原因, 上面的应用程序返回false并且依赖于它, 还有其他一些表达式该怎么办?

如果我们改变大于号>to<并运行此代码, 我们应该得到" false"。假设上面的符号更改是一个错误, 并且由于该错误, 程序返回了意外的结果。开发团队将如何跟踪该错误并确保不会再次发生?

上面的表达式是一个不变式的例子。为了保证代码按预期返回" true", Node.js开发团队使用assert模块测试表达式。

断言方法的类型

有不同的断言方法-你可以使用哪种方法归结为要在Node.js应用程序中测试不变量的方法。要使用此Node.js模块, 请通过运行以下命令进行安装:

npm i assert

让我们深入研究各种断言方法以及在应用程序中可以在何处使用它们的示例。

的断言(值[, 消息])方法

此方法用于验证不变量的值是否为true。这是别名assert.ok(value [, message])并可以以相同的方式使用。

//import assert module
var assert = require('assert');

//declare variables
var a = 5;
var b = 3;

//This code below would throw an assert error and end program
assert(a < b);

/**This is an expample to show how to use assert.ok(). Comment assert() out, run this code to get the same response.
assert.ok(a < b);
**/

上面的程序是如何使用断言()应用程序中的方法。如果仔细观察, 你会发现该表达式与用于解释不变式的第一个表达式相同。

我们为制作了一个自定义演示.
不完全是。点击这里查看.

使用Assert模块来验证Node.js中的不变式1

注意:如果不变表达式返回true, 则没有assert方法将引发异常。仅当不变量返回false或0时, 它们才会引发错误。

的Assert.deepStrictEqual(实际, 预期[, 消息])方法

此方法在严格模式下使用断言, 因此你在检查是否相等时将使用此方法, 而不是assert.deepEqual方法。这是因为assert.deepEqual用途抽象相等比较;因此, 它可以产生令人惊讶的结果。

如何使用的例子Assert.deepStrictEqual()方法在下面的表达式中说明:

//This is how to import the assert module in strict mode
const assert = require('assert').strict;

// This fails because 1 !== '1 for strict equality comparison.
assert.deepStrictEqual({ a: 1 }, { a: '1' });

/**Where { a: 1 } = actual value and { a: '1' } = expected value.
AssertionError: Expected inputs to be strictly deep-equal:
**/

的Assert.fail([消息])方法

假设你需要在断言返回false时向自定义测试添加自定义消息。这是一种简单的调试方法。例如, 开发人员将以下代码嵌入他们的代码中, 以便他们知道错误是什么:

console.log('When you get here, log this so i know my error')

你可以使用以下表达式插入自定义错误消息:

//Import assert module
const assert = require('assert').strict;

/** AssertionError [ERR_ASSERTION]: Failed. This just prints failed as error message. This is not a good practice**/
assert.fail();

// AssertionError [ERR_ASSERTION]: This is why I failed
assert.fail('This is why I failed');

// TypeError: This is why I failed
assert.fail(new TypeError('This is why I failed'));

的Assert.ifError(值)方法

想象一下:你刚遇到一个错误, 你可能知道错误来自何行, 但你不仅仅了解为什么程序会引发错误。

随着Assert.ifError方法, 你可以测试错误回调参数以了解错误的确切来源。下面的表达式说明了使用此方法的快速示例:

//This method is used in strict mode
const assert = require('assert').strict;

//Define error callback arguement
let err;
(function error1() {
  err = new Error('test error');
})();

//create an ifError function
(function ifError1() {
//return this error if program resolves into an error
  assert.ifError(err);
})();
/**AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
at ifError1
at error1 **/

的Assert.doesNotMatch(string, regexp [, message])方法

此方法用于验证实际输入字符串与预期表达式不匹配。的assert.doesNotMatch()Node.js版本v13.6.0, v12.16.0中添加的方法是实验性的, 可能已被完全删除。该方法当前在严格模式下使用断言。

下面的简单表达式显示了如何使用assert.doesNotMatch()验证不变式的方法。

//import assert using strict mode
const assert = require('assert').strict;

assert.doesNotMatch('I will fail', /fail/);
/** AssertionError [ERR_ASSERTION]: The input was expected to not match because fail is contained in the actual and expected string ...**/

assert.doesNotMatch(123, /pass/);
/**AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.**/

assert.doesNotMatch('I will pass', /different/);
/** This passes the test with no error since actual and expeted string have no word alike **/

的Assert.doesNotReject(asyncFn \ [, 错误\] [, 消息])方法

此方法用于检查异步函数中未拒绝诺言。如果表达式未返回承诺, Assert.doesNotReject()返回被拒绝的承诺。

使用此方法不是很有用, 因为捕获拒绝只是再次拒绝它是没有好处的。最好的办法是在不应拒绝的特定代码路径旁边添加注释, 并尽可能使错误消息具有表现力。

下面的表达式显示了有关如何使用此方法的示例:

(async () => {
  await assert.doesNotReject(
    async () => {
      throw new TypeError('Wrong value');
    }, SyntaxError
  );
})();

assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
  .then(() => {
    // ...
  });

如果你要检查不变量的承诺是否被拒绝怎么办?

在这种情况下使用的assert方法是Assert.rejects()方法。此方法在异步函数中等待返回的诺言, 以验证诺言是否被拒绝。

如果未拒绝承诺, 则会引发错误。下面的表达式显示了我们可以使用此方法的简单方法。

(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value');
    }, {
      name: 'TypeError', message: 'Wrong value'
    }
  );
})();

assert.rejects(
  Promise.reject(new Error('Wrong value')), Error
).then(() => {
  // ...
});

在严格模式和旧模式下声明

在严格模式下声明涉及使用严格平等比较验证不变式的方法。在断言严格模式下, 非严格方法的行为与其相对严格方法相同。

例如, assert.deepEqual()会像assert.deepStrictEqual(), 而assert.notEqual()会像assert.notStrictEqual().

要在严格模式下使用断言, 请使用以下任何一种方法将断言模块导入应用程序:

//import the assert module using strict mode
const assert = require('assert').strict;

//import the assert module using strict mode
const assert = require('assert/strict');

在传统模式下, 不变量的比较涉及使用抽象相等比较。建议始终使用严格模式比较不变量的实际值和期望值。

要将断言模块使用旧版模式​​导入你的应用程序, 请使用以下表达式:

const assert = require('assert');

这是旧模式下的不同断言比较方法。

的Assert.deepEqual(实际, 预期[, 消息])方法

断言深层相等方法使用抽象相等比较。它用于检查实际结果与预期结果之间的相等性。使用此方法, 还可以测试子属性。有关如何使用assert.deepEqual()方法显示在下面的表达式中:

const assert = require('assert');

const val1 = {
  x: {
    y: 1
  }
};
const val2 = {
  x: {
    y: 2
  }
};
const val3 = {
  x: {
    y: 1
  }
};

assert.deepEqual(val1, val3);
// Returns OK since val1 is equal to val3

// Values of b are different (Child properties)
assert.deepEqual(val1, val2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

如果要为了平等而要检验是否存在严重的不平等怎么办?在这种情况下使用的assert方法是assert.notDeepEqual(actual, Expected [, message])。此方法用于测试深度不平等, 如果实际值和期望值相等, 则会抛出异常。

下面显示了如何使用此方法的示例:

const assert = require('assert');

const val1 = {
  x: {
    y: 1
  }
};
const val2 = {
  x: {
    y: 2
  }
};
const val3 = {
  x: {
    y: 1
  }
};

assert.notDeepEqual(val1, val3);
// AssertionError: { x: { y: 1 } } notDeepEqual { x: { y: 2 } }

/** Values of b are different (Child properties)**/
assert.notDeepEqual(val1, val2);
// Ok because val1 and val2 are not equal

注意:由于此方法不稳定, 因此不建议使用, 因此建议在严格模式下使用assert, 即Asset.deepStrictEqual和Asset.notDeepStrictEqual方法。

的Assert.equal(实际, 预期[, 消息])方法

该方法用于测试实际结果与预期结果之间的浅层比较, 方法是抽象相等比较。它很少用于测试子代价值, 因为它是用于浅层测试的, 因此建议你使用Assert.deepStrictEqual()方法代替此方法。如何使用的例子Assert.equal()在下面的表达式中显示:

//Import the assert module
const assert = require('assert');

assert.equal(1, 1);
// This throws no exception since 1 == 1

assert.equal(1, '1');
/** This throws no exception since with abstract equality comparison 1 == '1' **/

assert.equal(NaN, NaN);
// This throws no exception

assert.equal(1, 2);
// This throws an error, AssertionError: 1 == 2

assert.equal({ a: { x: 1 } }, { a: { x: 1 } });
/**This throws an error AssertionError: { a: { x: 1 } } == { a: { x: 1 } } because it dosen't check child value**/

的assert.notEqual()方法用于检查浅层不等式, 就像assert.equal()用于检查是否相等。

的Assert.notEqual(实际, 预期[, 消息])方法

就像assert.equal方法用于浅层相等比较一样, 此方法也用于浅层不平等比较。

你不应使用此方法来测试子值, 因为它是用于浅层测试的。

同样, 这是一个遗留模式不变方法, 并且遗留模式不变方法用于抽象比较。为了进行严格的比较, 也为了测试子代价值, 请使用assert.notStrictEqual方法。

//Import the assert module
const assert = require('assert');

assert.notEqual(1, 1);
// This throws an exception since 1 == 1

assert.notEqual(1, '1');
/** This throws an exception since with abstract equality comparison 1 == '1' **/

assert.notEqual(1, 2);
// This throws no error, since 1 !== 2

的Assert.notDeepEqual(实际, 预期[, 消息])方法

断言非深度相等方法用于检查实际结果与预期结果之间的浅层不平等。如果要测试子属性之间的比较, 则此方法非常适合你。

有关如何使用assert.notDeepEqual()方法显示在下面的表达式中:

//Import module
const assert = require('assert');

const val1 = {
  x: {
    y: 1
  }
};
const val2 = {
  x: {
    y: 2
  }
};
const val3 = {
  x: {
    y: 1
  }
};

assert.notDeepEqual(val1, val3);
// Returns an error, since val1 is equal to val3

// Values of b are different (Child properties)
assert.deepEqual(val1, val2);
// Returns no error since the child properties are not equal

总结

在本文中, 我们了解了如何以及为什么需要在应用程序中使用Node.Js断言模块。

建议在编写生产代码时主要在严格模式下使用断言, 因为它们的旧版对等物可能会产生意外结果, 因为它们使用抽象相等比较, 并且当前已贬值。

你可能对此感兴趣文件资料解释了如何创建一个呼叫跟踪器对象, 这将验证是否将不变表达式称为所需的次数。

非常感谢你阅读本文。

只有200 监视生产中失败和缓慢的网络请求

部署基于节点的Web应用程序或网站很容易。确保你的Node实例继续为你的应用程序提供资源是一件很困难的事情。如果你希望确保成功完成对后端或第三方服务的请求,

尝试notlogy

.

LogRocket网络请求监控

https://notlogy.com/signup/

日志火箭就像Web应用程序的DVR一样, 实际上记录了你网站上发生的一切。无需猜测问题发生的原因, 你可以汇总并报告有问题的网络请求, 以快速了解根本原因。

notlogy用你的应用程序记录基线性能计时, 例如页面加载时间, 到第一个字节的时间, 缓慢的网络请求, 并记录Redux, NgRx和Vuex的操作/状态。

免费开始监控

.

一盏木

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: