Assert

Stability: 2 - Stable

Модуль assert предоставляет простой набор проверочных тестов, которые можно использовать для проверки инвариантов.

assert(value[, message])

Added in: v0.5.9

value <any>
message <any>

Псевдоним для assert.ok().

const assert = require('assert');

assert(true);  // OK
assert(1);     // OK
assert(false);
  // throws "AssertionError: false == true"
assert(0);
  // throws "AssertionError: 0 == true"
assert(false, 'it\'s false');
  // throws "AssertionError: it's false"

assert.deepEqual(actual, expected[, message])

Added in: v0.1.21

actual <any>
expected <any>
message <any>

Проверяет глубокое равенство параметров actual и expected. Примитивные значения сравниваются оператором сравнения на равенство (==).

Рассматриваются только перечисляемые собственные свойства. Реализация deepEqual() не проверяет прототипы объектов, присоединённые символы или непрозрачные свойства. Это может привести к некоторым потенциально неожиданным результатам. Например, следующий пример не генерирует AssertionError, потому что свойства объекта Error не перечисляемые:

// WARNING: This does not throw an AssertionError!
assert.deepEqual(Error('a'), Error('b'));

«Глубокое» равенство означает, что перечисляемые «собственные» свойства дочерних объектов также оцениваются:

const assert = require('assert');

const obj1 = {
  a : {
    b : 1
  }
};
const obj2 = {
  a : {
    b : 2
  }
};
const obj3 = {
  a : {
    b : 1
  }
}
const obj4 = Object.create(obj1);

assert.deepEqual(obj1, obj1);
  // OK, object is equal to itself

assert.deepEqual(obj1, obj2);
  // AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
  // values of b are different

assert.deepEqual(obj1, obj3);
  // OK, objects are equal

assert.deepEqual(obj1, obj4);
  // AssertionError: { a: { b: 1 } } deepEqual {}
  // Prototypes are ignored

Если значения не равны, выбрасывается AssertionError с свойством message, установленным равным значению параметра message. Если параметр message не определён, используется сообщение об ошибке по умолчанию.

assert.deepStrictEqual(actual, expected[, message])

Added in: v1.2.0

actual <any>
expected <any>
message <any>

В целом идентично assert.deepEqual(), за исключением двух моментов. Во-первых, примитивные значения сравниваются с использованием оператора строгого равенства (===). Во-вторых, при сравнении объектов производится проверка строгого равенства их прототипов.

const assert = require('assert');

assert.deepEqual({a:1}, {a:'1'});
  // OK, because 1 == '1'

assert.deepStrictEqual({a:1}, {a:'1'});
  // AssertionError: { a: 1 } deepStrictEqual { a: '1' }
  // because 1 !== '1' using strict equality

assert.doesNotThrow(block[, error][, message])

Added in: v0.1.21

block <Function>
error <RegExp> | <Function>
message <any>

Проверяет, что функция block не вызывает ошибку. Подробнее см. assert.throws().

При вызове assert.doesNotThrow() функция block будет вызвана немедленно.

Если возникает ошибка, и она соответствует типу, указанному в параметре error, то выбрасывается AssertionError. Если ошибка имеет другой тип или параметр error не определён, ошибка передаётся обратно вызывающей стороне.

Следующий пример, например, выбросит TypeError, так как в утверждении нет соответствующего типа ошибки:

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

Однако, следующий пример приведёт к AssertionError с сообщением «Получена нежелательная исключение (TypeError)..»:

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError
);

Если возникает AssertionError и предоставляется значение для параметра message, значение message будет добавлено к сообщению об ошибке AssertionError.

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
  'Whoops'
);
// Throws: AssertionError: Got unwanted exception (TypeError). Whoops

assert.equal(actual, expected[, message])

Added in: v0.1.21

actual <any>
expected <any>
message <any>

Проверяет поверхностное равенство между параметрами actual и expected с использованием оператора сравнения на равенство (==).

const assert = require('assert');

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

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

assert.fail(actual, expected, message, operator)

Added in: v0.1.21

actual <any>
expected <any>
message <any>
operator <String>

Выбрасывает AssertionError. Если message ложно, сообщение об ошибке устанавливается как значения actual и expected разделённые указанным operator. В противном случае сообщение об ошибке — значение message.

const assert = require('assert');

assert.fail(1, 2, undefined, '>');
  // AssertionError: 1 > 2

assert.fail(1, 2, 'whoops', '>');
  // AssertionError: whoops

assert.ifError(value)

Added in: v0.1.97

value <any>

Выбрасывает value если value истинно. Это полезно при тестировании аргумента error в обратных вызовах.

const assert = require('assert');

assert.ifError(0); // OK
assert.ifError(1); // Throws 1
assert.ifError('error') // Throws 'error'
assert.ifError(new Error()); // Throws Error

assert.notDeepEqual(actual, expected[, message])

Added in: v0.1.21

actual <any>
expected <any>
message <any>

Проверяет любые глубокие неравенства. Противоположность assert.deepEqual().

const assert = require('assert');

const obj1 = {
  a : {
    b : 1
  }
};
const obj2 = {
  a : {
    b : 2
  }
};
const obj3 = {
  a : {
    b : 1
  }
};
const obj4 = Object.create(obj1);

assert.notDeepEqual(obj1, obj1);
  // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2);
  // OK, obj1 and obj2 are not deeply equal

assert.notDeepEqual(obj1, obj3);
  // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4);
  // OK, obj1 and obj4 are not deeply equal

Если значения глубоко равны, выбрасывается AssertionError с свойством message, установленным равным значению параметра message. Если параметр message не определён, используется сообщение об ошибке по умолчанию.

assert.notDeepStrictEqual(actual, expected[, message])

Added in: v1.2.0

actual <any>
expected <any>
message <any>

Проверяет глубокое строгое неравенство. Противоположность assert.deepStrictEqual().

const assert = require('assert');

assert.notDeepEqual({a:1}, {a:'1'});
  // AssertionError: { a: 1 } notDeepEqual { a: '1' }

assert.notDeepStrictEqual({a:1}, {a:'1'});
  // OK

Если значения глубоко и строго равны, выбрасывается AssertionError с свойством message, установленным равным значению параметра message. Если параметр message не определён, используется сообщение об ошибке по умолчанию.

assert.notEqual(actual, expected[, message])

Added in: v0.1.21

actual <any>
expected <any>
message <any>

Проверяет поверхностное неравенство с использованием оператора сравнения на неравенство (!=).

const assert = require('assert');

assert.notEqual(1, 2);
  // OK

assert.notEqual(1, 1);
  // AssertionError: 1 != 1

assert.notEqual(1, '1');
  // AssertionError: 1 != '1'

Если значения равны, выбрасывается AssertionError с свойством message, установленным равным значению параметра message. Если параметр message не определён, используется сообщение об ошибке по умолчанию.

assert.notStrictEqual(actual, expected[, message])

Added in: v0.1.21

actual <any>
expected <any>
message <any>

Проверяет строгое неравенство, определённое оператором строгого неравенства (!==).

const assert = require('assert');

assert.notStrictEqual(1, 2);
  // OK

assert.notStrictEqual(1, 1);
  // AssertionError: 1 !== 1

assert.notStrictEqual(1, '1');
  // OK

Если значения строго равны, выбрасывается AssertionError с свойством message, установленным равным значению параметра message. Если параметр message не определён, используется сообщение об ошибке по умолчанию.

assert.ok(value[, message])

Added in: v0.1.21

value <any>
message <any>

Проверяет, что value истинно. Эквивалентно assert.equal(!!value, true, message).

Если value не истинно, выбрасывается AssertionError с свойством message, установленным равным значению параметра message. Если параметр message является undefined, используется сообщение об ошибке по умолчанию.

const assert = require('assert');

assert.ok(true);  // OK
assert.ok(1);     // OK
assert.ok(false);
  // throws "AssertionError: false == true"
assert.ok(0);
  // throws "AssertionError: 0 == true"
assert.ok(false, 'it\'s false');
  // throws "AssertionError: it's false"

assert.strictEqual(actual, expected[, message])

Added in: v0.1.21

actual <any>
expected <any>
message <any>

Проверяет строгое равенство, определённое оператором строгого равенства (===).

const assert = require('assert');

assert.strictEqual(1, 2);
  // AssertionError: 1 === 2

assert.strictEqual(1, 1);
  // OK

assert.strictEqual(1, '1');
  // AssertionError: 1 === '1'

Если значения не строго равны, выбрасывается AssertionError с свойством message установленным равным значению параметра message. Если параметр message не определен, используется сообщение об ошибке по умолчанию.

assert.throws(block[, error][, message])

Добавлен в: v0.1.21

block <Функция>
error <Выражение регулярного типа> | <Функция>
message <любой>

Ожидается, что функция block выбросит ошибку.

Если указано, error может быть конструктором, RegExp или функцией валидации.

Если указано, message будет сообщением, предоставляемым AssertionError в случае, если блок не выбросит ошибку.

Проверка instanceof с использованием конструктора:

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  Error
);

Проверка сообщения об ошибке с использованием RegExp:

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  /value/
);

Пользовательская валидация ошибок:

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  function(err) {
    if ( (err instanceof Error) && /value/.test(err) ) {
      return true;
    }
  },
  'unexpected error'
);

Обратите внимание, что error не может быть строкой. Если в качестве второго аргумента передается строка, то считается, что error опущено, и строка будет использована для message вместо этого. Это может привести к легко упускаемым ошибкам:

// THIS IS A MISTAKE! DO NOT DO THIS!
assert.throws(myFunction, 'missing foo', 'did not throw with expected message');

// Do this instead.
assert.throws(myFunction, /missing foo/, 'did not throw with expected message');

© Joyent, Inc. and other Node contributors
Licensed under the MIT License.
Node.js is a trademark of Joyent, Inc. and is used with its permission.
We are not endorsed by or affiliated with Joyent.
https://nodejs.org/dist/latest-v4.x/docs/api/assert.html