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

function dockerClientSupportsVolumes(dockerVersionString) {
    assert.string(dockerVersionString, 'dockerVersionString');

    var dockerVersion = common.parseDockerVersion(dockerVersionString);

    if (dockerVersion.major < 1 || dockerVersion.minor < 9) {
        return false;
    }

    return true;
}

function vmStart(uuid, options, callback) {
    assert.string(uuid, 'uuid');
    assert.object(options, 'options');
    assert.optionalBool(options.force, 'options.force');
    assert.object(options.log, 'options.log');
    assert.func(callback);
    var optStr = '';
    if (options.force) {
        optStr += ' -F';
    }
    var cmd = format('/usr/sbin/vmadm start%s %s', optStr, uuid);
    options.log.trace({cmd: cmd}, 'start vmStart');
    exec(cmd, function (err, stdout, stderr) {
        options.log.trace({cmd: cmd, err: err, stdout: stdout, stderr: stderr},
            'finish vmStart');
        callback(err);
    });
}

HttpClient.prototype.basicAuth = function basicAuth(username, password) {
    if (username === false) {
        delete this.headers.authorization;
    } else {
        assert.string(username, 'username');
        assert.string(password, 'password');

        var buffer = new Buffer(username + ':' + password, 'utf8');
        this.headers.authorization = 'Basic ' +
            buffer.toString('base64');
    }

    return (this);
};

function getImageIcon(uuid, filePath, account, options, callback) {
    var self = this;
    assert.string(uuid, 'uuid');
    assert.string(filePath, 'filePath');
    if (typeof (account) === 'function') {
        callback = account;
        options = {};
        account = undefined;
    } else if (typeof (options) === 'function') {
        callback = options;
        options = {};
    }
    assert.optionalString(account, 'account');
    assert.object(options, 'options');
    assert.optionalObject(options.headers, 'options.headers');
    assert.func(callback, 'callback');

    var path = self._path(format('/images/%s/icon', uuid), {
        channel: self.channel,
        account: account

function assertPeerIdentifier(peer) {
        assert.string(peer.pgUrl, 'peer.pgUrl');
        assert.string(peer.backupUrl, 'peer.backupUrl');
    }

function updateRecordSet(hostedZoneId, name, type, value, ttl, cb) {
	"use strict";
	assert.string(hostedZoneId, "hostedZoneId");
	assert.string(name, "name");
	assert.string(type, "type");
	assert.string(value, "value");
	assert.number(ttl, "ttl");
	assert.func(cb, "cb");
	var route53 = new AWS.Route53();
	var params = {
		"ChangeBatch": {
			"Changes": [{
				"Action": "UPSERT",
				"ResourceRecordSet": {
					"Name": name,
					"Type": type,
					"TTL": ttl,
					"ResourceRecords": [{
						"Value": value
					}]
				}

function zfsRenameSnapshot(a, b, options, callback) {
    assert.string(a, 'a');
    assert.string(b, 'b');
    assert.object(options, 'options');
    assert.optionalBool(options.recursive, 'options.recursive');
    assert.object(options.log, 'options.log');
    assert.func(callback);
    var optStr = '';
    if (options.recursive) {
        optStr += ' -r';
    }
    var cmd = format('/usr/sbin/zfs rename%s %s', optStr, a, b);
    options.log.trace({cmd: cmd}, 'start zfsRenameSnapshot');
    exec(cmd, function (err, stdout, stderr) {
        options.log.trace({cmd: cmd, err: err, stdout: stdout, stderr: stderr},
            'finish zfsRenameSnapshot');
        callback(err);
    });
}

function dockerImageJsonToModel(imageJson, opts) {
    assert.object(imageJson, 'imageJson');
    assert.object(opts, 'opts');
    assert.string(opts.config_digest, 'opts.config_digest');
    assert.optionalBool(opts.head, 'opts.head');
    assert.string(opts.image_uuid, 'opts.image_uuid');
    assert.string(opts.manifest_str, 'opts.manifest_str');
    assert.string(opts.manifest_digest, 'opts.manifest_digest');
    assert.optionalString(opts.owner_uuid, 'opts.owner_uuid');
    assert.number(opts.size, 'opts.size');

    var modelObj = {
        config_digest: opts.config_digest,
        head: (opts.head || false),
        image: imageJson,
        image_uuid: opts.image_uuid,
        manifest_digest: opts.manifest_digest,
        manifest_str: opts.manifest_str,
        owner_uuid: opts.owner_uuid,
        size: (opts.size || 0)
    };

    return modelObj;
}

JirashApi.prototype.commentIssue = function commentIssue(opts, cb) {
    assert.object(opts, 'opts');
    assert.string(opts.issueIdOrKey, 'opts.issueIdOrKey');
    assert.string(opts.issueComment, 'opts.issueComment');

    var context = {
        api: this
    };

    var post = {'body': opts.issueComment};

    vasync.pipeline(
        {
            arg: context,
            funcs: [
                ctxJiraClient,

                function putIt(ctx, next) {
                    ctx.jiraClient.post(

function deleteContainer(opts, callback) {
    assert.object(opts, 'opts');
    assert.bool(opts.force, 'opts.force');
    assert.bool(opts.link, 'opts.link');
    assert.optionalObject(opts.log, 'opts.log');
    assert.string(opts.req_id, 'opts.req_id');
    assert.string(opts.id, 'opts.id');
    assert.object(opts.account, 'opts.account');

    var log = opts.log || this.log;
    var vmapi = opts.app.vmapi;

    var deleteHeaders = { headers: { 'x-request-id': opts.req_id } };
    var deleteParams = {
        context: opts.context,
        creator_uuid: opts.creator_uuid,
        origin: opts.origin,
        owner_uuid: opts.account.uuid,
        sync: true,
        uuid: opts.vm.uuid
    };