assert.js
No OneTemporary
Actions

Size

7 KB

Referenced Files

None

Subscribers

None

assert.js
View Options

	import { test, testThrows, testDeep, summary } from './helpers.js';
	import assert from 'node:assert';

	console.log('assert.ok\n');

	let threw = false;
	try { assert(false); } catch (e) { threw = true; }
	test('assert(false) throws', threw, true);

	threw = false;
	try { assert(0); } catch (e) { threw = true; }
	test('assert(0) throws', threw, true);

	threw = false;
	try { assert(''); } catch (e) { threw = true; }
	test('assert("") throws', threw, true);

	threw = false;
	try { assert(null); } catch (e) { threw = true; }
	test('assert(null) throws', threw, true);

	threw = false;
	try { assert(1); } catch (e) { threw = true; }
	test('assert(1) does not throw', threw, false);

	threw = false;
	try { assert('hello'); } catch (e) { threw = true; }
	test('assert("hello") does not throw', threw, false);

	threw = false;
	try { assert.ok(false, 'custom message'); } catch (e) { threw = true; }
	test('assert.ok with custom message throws', threw, true);

	console.log('\nassert.equal / assert.notEqual\n');

	threw = false;
	try { assert.equal(1, 1); } catch (e) { threw = true; }
	test('equal(1, 1) passes', threw, false);

	threw = false;
	try { assert.equal(1, '1'); } catch (e) { threw = true; }
	test('equal(1, "1") passes (loose)', threw, false);

	threw = false;
	try { assert.equal(1, 2); } catch (e) { threw = true; }
	test('equal(1, 2) throws', threw, true);

	threw = false;
	try { assert.equal(null, undefined); } catch (e) { threw = true; }
	test('equal(null, undefined) passes (loose)', threw, false);

	threw = false;
	try { assert.notEqual(1, 2); } catch (e) { threw = true; }
	test('notEqual(1, 2) passes', threw, false);

	threw = false;
	try { assert.notEqual(1, 1); } catch (e) { threw = true; }
	test('notEqual(1, 1) throws', threw, true);

	console.log('\nassert.strictEqual / assert.notStrictEqual\n');

	threw = false;
	try { assert.strictEqual(1, 1); } catch (e) { threw = true; }
	test('strictEqual(1, 1) passes', threw, false);

	threw = false;
	try { assert.strictEqual('a', 'a'); } catch (e) { threw = true; }
	test('strictEqual("a", "a") passes', threw, false);

	threw = false;
	try { assert.strictEqual(1, '1'); } catch (e) { threw = true; }
	test('strictEqual(1, "1") throws', threw, true);

	threw = false;
	try { assert.strictEqual(null, undefined); } catch (e) { threw = true; }
	test('strictEqual(null, undefined) throws', threw, true);

	threw = false;
	try { assert.strictEqual(NaN, NaN); } catch (e) { threw = true; }
	test('strictEqual(NaN, NaN) passes', threw, false);

	threw = false;
	try { assert.notStrictEqual(1, 2); } catch (e) { threw = true; }
	test('notStrictEqual(1, 2) passes', threw, false);

	threw = false;
	try { assert.notStrictEqual(1, 1); } catch (e) { threw = true; }
	test('notStrictEqual(1, 1) throws', threw, true);

	console.log('\nassert.deepEqual / assert.deepStrictEqual\n');

	threw = false;
	try { assert.deepEqual({ a: 1 }, { a: 1 }); } catch (e) { threw = true; }
	test('deepEqual({a:1}, {a:1}) passes', threw, false);

	threw = false;
	try { assert.deepEqual([1, 2, 3], [1, 2, 3]); } catch (e) { threw = true; }
	test('deepEqual arrays passes', threw, false);

	threw = false;
	try { assert.deepEqual({ a: 1 }, { a: 2 }); } catch (e) { threw = true; }
	test('deepEqual({a:1}, {a:2}) throws', threw, true);

	threw = false;
	try { assert.deepEqual([1, 2], [1, 2, 3]); } catch (e) { threw = true; }
	test('deepEqual different length arrays throws', threw, true);

	threw = false;
	try { assert.deepStrictEqual({ a: 1 }, { a: 1 }); } catch (e) { threw = true; }
	test('deepStrictEqual({a:1}, {a:1}) passes', threw, false);

	threw = false;
	try { assert.deepStrictEqual({ a: 1 }, { a: '1' }); } catch (e) { threw = true; }
	test('deepStrictEqual({a:1}, {a:"1"}) throws', threw, true);

	threw = false;
	try { assert.deepStrictEqual({ a: { b: { c: 42 } } }, { a: { b: { c: 42 } } }); } catch (e) { threw = true; }
	test('deepStrictEqual nested objects passes', threw, false);

	threw = false;
	try { assert.notDeepEqual({ a: 1 }, { a: 2 }); } catch (e) { threw = true; }
	test('notDeepEqual({a:1}, {a:2}) passes', threw, false);

	threw = false;
	try { assert.notDeepEqual({ a: 1 }, { a: 1 }); } catch (e) { threw = true; }
	test('notDeepEqual({a:1}, {a:1}) throws', threw, true);

	threw = false;
	try { assert.notDeepStrictEqual({ a: 1 }, { a: '1' }); } catch (e) { threw = true; }
	test('notDeepStrictEqual({a:1}, {a:"1"}) passes', threw, false);

	console.log('\nassert.fail\n');

	threw = false;
	try { assert.fail('boom'); } catch (e) { threw = true; }
	test('fail("boom") throws', threw, true);

	threw = false;
	try { assert.fail(); } catch (e) { threw = true; }
	test('fail() throws', threw, true);

	let failMsg = '';
	try { assert.fail('specific message'); } catch (e) { failMsg = e.message; }
	test('fail message is preserved', failMsg, 'specific message');

	console.log('\nassert.ifError\n');

	threw = false;
	try { assert.ifError(null); } catch (e) { threw = true; }
	test('ifError(null) does not throw', threw, false);

	threw = false;
	try { assert.ifError(undefined); } catch (e) { threw = true; }
	test('ifError(undefined) does not throw', threw, false);

	threw = false;
	try { assert.ifError(new Error('oops')); } catch (e) { threw = true; }
	test('ifError(Error) throws', threw, true);

	threw = false;
	try { assert.ifError('some error'); } catch (e) { threw = true; }
	test('ifError(string) throws', threw, true);

	console.log('\nassert.throws / assert.doesNotThrow\n');

	threw = false;
	try { assert.throws(() => { throw new Error('boom'); }); } catch (e) { threw = true; }
	test('throws with throwing fn passes', threw, false);

	threw = false;
	try { assert.throws(() => {}); } catch (e) { threw = true; }
	test('throws with non-throwing fn throws', threw, true);

	threw = false;
	try { assert.doesNotThrow(() => {}); } catch (e) { threw = true; }
	test('doesNotThrow with non-throwing fn passes', threw, false);

	threw = false;
	try { assert.doesNotThrow(() => { throw new Error('oops'); }); } catch (e) { threw = true; }
	test('doesNotThrow with throwing fn throws', threw, true);

	console.log('\nassert.match / assert.doesNotMatch\n');

	threw = false;
	try { assert.match('hello world', /hello/); } catch (e) { threw = true; }
	test('match passes when pattern matches', threw, false);

	threw = false;
	try { assert.match('hello world', /xyz/); } catch (e) { threw = true; }
	test('match throws when pattern does not match', threw, true);

	threw = false;
	try { assert.doesNotMatch('hello world', /xyz/); } catch (e) { threw = true; }
	test('doesNotMatch passes when pattern does not match', threw, false);

	threw = false;
	try { assert.doesNotMatch('hello world', /hello/); } catch (e) { threw = true; }
	test('doesNotMatch throws when pattern matches', threw, true);

	console.log('\nassert.rejects / assert.doesNotReject\n');

	let resolved = false;
	await assert.rejects(async () => { throw new Error('boom'); });
	resolved = true;
	test('rejects resolves when fn rejects', resolved, true);

	resolved = false;
	try { await assert.rejects(async () => {}); } catch (e) { resolved = false; }
	test('rejects rejects when fn does not reject', resolved, false);

	resolved = false;
	await assert.doesNotReject(async () => {});
	resolved = true;
	test('doesNotReject resolves when fn does not reject', resolved, true);

	console.log('\nAssertionError\n');

	test('AssertionError is a constructor', typeof assert.AssertionError, 'function');

	const ae = new assert.AssertionError({ message: 'test', actual: 1, expected: 2, operator: 'strictEqual' });
	test('AssertionError has name', ae.name, 'AssertionError');
	test('AssertionError has message', ae.message, 'test');
	test('AssertionError has actual', ae.actual, 1);
	test('AssertionError has expected', ae.expected, 2);
	test('AssertionError has operator', ae.operator, 'strictEqual');

	summary();

File Metadata

Mime Type: application/javascript
Expires: Fri, Apr 3, 11:06 PM (2 d)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 521300
Default Alt Text: assert.js (7 KB)

Event Timeline