How to use the assert-plus.bool function in assert-plus

IMGADM.prototype.configAddSource = function configAddSource(
        source, skipPingCheck, callback) {
    assert.object(source, 'source');
    assert.string(source.url, 'source.url');
    assert.optionalString(source.type, 'source.type');
    assert.bool(skipPingCheck, 'skipPingCheck');
    assert.func(callback, 'callback');
    var self = this;

    self._addSource(source, skipPingCheck, function (addErr, changed) {
        if (addErr) {
            callback(addErr);
        } else if (changed) {
            if (!self.config.sources) {
                // Was implicitly getting the default source. Let's keep it.
                self.config.sources = [common.DEFAULT_SOURCE];
            }
            self.config.sources.push({url: source.url, type: source.type});
            self.saveConfig(function (saveErr) {
                if (saveErr) {
                    callback(saveErr);
                    return;

it('checks if a message type was stored', function () {
      assert.bool(
        response.locals.flash.has('success'),
        'Must return a boolean'
      );
    });
  });

function testSubcmdOk(subcmd, subcmdinfo, useenv, callback)
{
    var args;

    assertplus.string(subcmd, 'subcmd');
    assertplus.object(subcmdinfo, 'subcmdinfo');
    assertplus.arrayOfString(subcmdinfo.required, 'subcmdinfo.required');
    assertplus.bool(useenv, 'useenv');
    assertplus.ok(!subcmdinfo.destructive);

    testStart('subcmd "%s" with all required args (%s)', subcmd,
        useenv ? 'using env vars' : 'using args');
    args = subcmdinfo.required.slice(0);
    execChildForTest(subcmd, args, useenv, function (cmdresult) {
        if (!cmdResultCompleted(cmdresult))
            testFail('command timed out', cmdresult);
        else if (!cmdResultExitOk(cmdresult))
            testFail('command did not exit 0', cmdresult);
        else if (subcmd != 'help' && (cmdResultHasUsage(cmdresult, 'stdout') ||
            cmdResultHasUsage(cmdresult, 'stderr')))
            testFail('found usage message', cmdresult);
        else
            testPass();
        callback();

mod_assert.optionalObject(uopts, 'options');

	var baseOverride = false;
	var options = PI_DEFAULTS;

	if (uopts) {
		baseOverride = hasKey(uopts, 'base');
		options = mergeObjects(options, uopts);
		mod_assert.number(options.base, 'options.base');
		mod_assert.ok(options.base >= 2, 'options.base >= 2');
		mod_assert.ok(options.base <= 36, 'options.base <= 36');
		mod_assert.bool(options.allowSign, 'options.allowSign');
		mod_assert.bool(options.allowPrefix, 'options.allowPrefix');
		mod_assert.bool(options.allowTrailing,
		    'options.allowTrailing');
		mod_assert.bool(options.allowImprecise,
		    'options.allowImprecise');
		mod_assert.bool(options.trimWhitespace,
		    'options.trimWhitespace');
		mod_assert.bool(options.leadingZeroIsOctal,
		    'options.leadingZeroIsOctal');

		if (options.leadingZeroIsOctal) {
			mod_assert.ok(!baseOverride,
			    '"base" and "leadingZeroIsOctal" are ' +
			    'mutually exclusive');
		}
	}

	var c;
	var pbase = -1;
	var base = options.base;

function parseInteger(str, uopts)
{
	mod_assert.string(str, 'str');
	mod_assert.optionalObject(uopts, 'options');

	var baseOverride = false;
	var options = PI_DEFAULTS;

	if (uopts) {
		baseOverride = hasKey(uopts, 'base');
		options = mergeObjects(options, uopts);
		mod_assert.number(options.base, 'options.base');
		mod_assert.ok(options.base >= 2, 'options.base >= 2');
		mod_assert.ok(options.base <= 36, 'options.base <= 36');
		mod_assert.bool(options.allowSign, 'options.allowSign');
		mod_assert.bool(options.allowPrefix, 'options.allowPrefix');
		mod_assert.bool(options.allowTrailing,
		    'options.allowTrailing');
		mod_assert.bool(options.allowImprecise,
		    'options.allowImprecise');
		mod_assert.bool(options.trimWhitespace,
		    'options.trimWhitespace');
		mod_assert.bool(options.leadingZeroIsOctal,
		    'options.leadingZeroIsOctal');

		if (options.leadingZeroIsOctal) {
			mod_assert.ok(!baseOverride,
			    '"base" and "leadingZeroIsOctal" are ' +
			    'mutually exclusive');
		}
	}

const getEnv = (line) => {
  const match = envPattern.exec(line);
  assert.bool(match && match.length > 2, 'Line is not valid environment variable definition');
  return [match[1], match[2]];
};

function deleteImage(opts, callback) {
    assert.object(opts, 'opts');
    assert.optionalObject(opts.app, 'opts.app');
    assert.bool(opts.force, 'opts.force');
    assert.optionalObject(opts.log, 'opts.log');
    assert.string(opts.name, 'opts.name');
    assert.string(opts.req_id, 'opts.req_id');
    assert.object(opts.account, 'opts.account');

    var changes;
    var log = opts.log;

    log.debug({givenName: opts.name}, 'deleteImage');

    vasync.pipeline({funcs: [
        getImg,
        doDeleteImage
    ]}, function (err) {
        callback(err, changes);
    });

mod_assert.optionalObject(uopts, 'options');

	var baseOverride = false;
	var options = PI_DEFAULTS;

	if (uopts) {
		baseOverride = hasKey(uopts, 'base');
		options = mergeObjects(options, uopts);
		mod_assert.number(options.base, 'options.base');
		mod_assert.ok(options.base >= 2, 'options.base >= 2');
		mod_assert.ok(options.base <= 36, 'options.base <= 36');
		mod_assert.bool(options.allowSign, 'options.allowSign');
		mod_assert.bool(options.allowPrefix, 'options.allowPrefix');
		mod_assert.bool(options.allowTrailing,
		    'options.allowTrailing');
		mod_assert.bool(options.allowImprecise,
		    'options.allowImprecise');
		mod_assert.bool(options.trimWhitespace,
		    'options.trimWhitespace');
		mod_assert.bool(options.leadingZeroIsOctal,
		    'options.leadingZeroIsOctal');

		if (options.leadingZeroIsOctal) {
			mod_assert.ok(!baseOverride,
			    '"base" and "leadingZeroIsOctal" are ' +
			    'mutually exclusive');
		}
	}

	var c;
	var pbase = -1;
	var base = options.base;

function
answer(correct)
{
	mod_assert.bool(correct, 'correct');

	var out = mod_jsprim.parseInteger(correct ? THE_ANSWER :
	    THE_WRONG_ANSWER);

	if (out instanceof Error) {
		return (new mod_verror.VError(out, 'wrong answer'));
	}

	return (out);
}

}, function _initDb(needinit, cb) {
        assert.bool(needinit, 'needinit');
        assert.func(cb, 'cb');

        try {
            self.resolveVersionedPaths();
        } catch (e) {
            cb(new VE(e, 'failed to resolve versioned paths before running ' +
              'initdb'));
            return;
        }

        assert.string(self._pgInitDbPath, 'self._pgInitDbPath');

        if (!needinit) {
            log.info('database files exist; skip initdb');
            setImmediate(cb);
            return;