Repository files navigation

Encouragesprogramming with assertions by providing tools to compile them away.

See: "unassert - encourage reliable programming by writing assertions in production" -- talk at NodeFest 2015, and "One more thing..." in talk at NodeFest 2016, titled "From Library to Tool - power-assert as a General Purpose Assertion Enhancement Tool"

• unassertify: Browserify transform for unassert
• babel-plugin-unassert: Babel plugin for unassert
• webpack-unassert-loader: Webpack loader for unassert
• gulp-unassert: Gulp plugin for unassert
• unassert-cli: CLI for unassert
• rollup-plugin-unassert: RollupJS plugin for unassert

$ npm install --save-dev unassert

For givenmath.js below,

constassert=require('node:assert');functionadd(a,b){assert(typeofa==='number');console.assert(!isNaN(a));assert.equal(typeofb,'number');assert.ok(!isNaN(b));returna+b;}

ApplyunassertAst then generate modified code to console.

via CJS code

const{ unassertAst}=require('unassert');const{ parse}=require('acorn');const{ generate}=require('escodegen');const{ readFileSync}=require('node:fs');const{ join, dirname}=require('node:path');constfilepath=join(__dirname,'math.js');constast=parse(readFileSync(filepath),{ecmaVersion:'2022'});constmodifiedAst=unassertAst(ast);console.log(generate(modifiedAst));

or via ESM code

import{unassertAst}from'unassert';import{parse}from'acorn';import{generate}from'escodegen';import{readFileSync}from'node:fs';import{join,dirname}from'node:path';import{fileURLToPath}from'node:url';const__dirname=dirname(fileURLToPath(import.meta.url));constfilepath=join(__dirname,'math.js');constast=parse(readFileSync(filepath),{ecmaVersion:'2022'});constmodifiedAst=unassertAst(ast);console.log(generate(modifiedAst));

Then you will see assert calls disappear.

functionadd(a,b){returna+b;}

unassert package exports three functions.unassertAst is the main function.createVisitor anddefaultOptions are for customization.

const{ unassertAst}=require('unassert')

import{unassertAst}from'unassert'

Remove assertion calls fromast (ECMAScript AST). Default behaviour can be customized byoptions.ast is manipulated directly so returnedmodifiedAst will be the same instance ofast.

Object for configuration options. passedoptions isObject.assigned with default options. If not passed, default options will be used.

Target module names for assertion call removal.

For example, the default target modules are as follows.

{modules:['assert','assert/strict','node:assert','node:assert/strict']

In this case, unassert will remove assert variable declarations such as,

• import assert from "assert"
• import assert from "assert/strict"
• import assert from "node:assert"
• import assert from "node:assert/strict"
• import * as assert from "assert"
• import * as assert from "node:assert"
• import * as assert from "assert/strict"
• import * as assert from "node:assert/strict"
• import { strict as assert } from "assert"
• import { strict as assert } from "node:assert"
• import { default as assert } from "assert"
• import { default as assert } from "node:assert"
• const assert = require("assert")
• const assert = require("node:assert")
• const assert = require("assert/strict")
• const assert = require("node:assert/strict")
• const assert = require("assert").strict
• const assert = require("node:assert").strict
• const { strict: assert } = require("assert")
• const { strict: assert } = require("node:assert")

and assignments.

• assert = require("assert")
• assert = require("node:assert")
• assert = require("assert/strict")
• assert = require("node:assert/strict")
• assert = require("assert").strict
• assert = require("node:assert").strict

In this default case, unassert will remove assertion calls such as,

• assert(value, [message])
• assert.ok(value, [message])
• assert.equal(actual, expected, [message])
• assert.notEqual(actual, expected, [message])
• assert.strictEqual(actual, expected, [message])
• assert.notStrictEqual(actual, expected, [message])
• assert.deepEqual(actual, expected, [message])
• assert.notDeepEqual(actual, expected, [message])
• assert.deepStrictEqual(actual, expected, [message])
• assert.notDeepStrictEqual(actual, expected, [message])
• assert.match(string, regexp[, message])
• assert.doesNotMatch(string, regexp[, message])
• assert.throws(block, [error], [message])
• assert.doesNotThrow(block, [message])
• await assert.rejects(asyncFn, [error], [message])
• await assert.doesNotReject(asyncFn, [error], [message])
• assert.fail([message])
• assert.fail(actual, expected, message, operator)
• assert.ifError(value)

in addition, unassert removesconsole.assert calls as well.

• console.assert(value, [message])

unassert automatically removes assertion calls based on their imported variable names.

So if import declaration is as follows,

• import strictAssert, { ok, equal as eq } from 'node:assert/strict';

unassert removes allstrictAssert,ok,eq calls.

Please seecustomization example for more details.

const{ createVisitor}=require('unassert')

import{createVisitor}from'unassert'

Create visitor object to be used withestraverse.replace. Visitor can be customized byoptions.

const{ defaultOptions}=require('unassert')

import{defaultOptions}from'unassert'

Returns default options object forunassertAst andcreateVisitor function. In other words, returns

{modules:['assert','assert/strict','node:assert','node:assert/strict']}

You can customize options such as target module names.

{modules:['node:assert','node:assert/strict','power-assert','invariant','nanoassert','uvu/assert']}

For givencustom.js below,

importinvariantfrom'invariant';importnassertfrom'nanoassert';import*asuvuassertfrom'uvu/assert';import{strictaspowerAssert}from'power-assert';import{defaultaslooseAssert}from'node:assert';importstrictAssert,{ok,equalaseq}from'node:assert/strict';asyncfunctionadd(a,b){strictAssert(!isNaN(a));looseAssert(typeofa==='number');eq(typeofb,'number');ok(!isNaN(b));powerAssert(typeofa===typeofb);nassert(!isNaN(a));uvuassert.is(Math.sqrt(4),2);uvuassert.is(Math.sqrt(144),12);uvuassert.is(Math.sqrt(2),Math.SQRT2);invariant(someTruthyVal,'This will not throw');invariant(someFalseyVal,'This will throw an error with this message');awaitstrictAssert.rejects(prms);awaitstrictAssert.doesNotReject(prms2);returna+b;}

ApplyunassertAst with customized options then generate modified code to console.

import{unassertAst}from'unassert';import{parse}from'acorn';import{generate}from'escodegen';import{readFileSync}from'node:fs';import{join,dirname}from'node:path';import{fileURLToPath}from'node:url';const__dirname=dirname(fileURLToPath(import.meta.url));constfilepath=join(__dirname,'custom.js');constast=parse(readFileSync(filepath),{ecmaVersion:'2022'});constmodifiedAst=unassertAst(ast,{modules:['node:assert','node:assert/strict','power-assert','invariant','nanoassert','uvu/assert']});console.log(generate(modifiedAst));

Then you will see all assert calls disappear.

asyncfunctionadd(a,b){returna+b;}

We support Node under maintenance. In other words, we stop supporting old Node version whentheir maintenance ends.

This means that any other environment is not supported.

NOTE: If unassert works in any of the unsupported environments, it is purely coincidental and has no bearing on future compatibility. Use at your own risk.

• Takuto Wada

• Renée Kooi
• Jordan Harband

Licensed under theMIT license.