567 lines
25 KiB
JavaScript
567 lines
25 KiB
JavaScript
var _ = require('lodash'),
|
|
sdk = require('postman-collection'),
|
|
colors = require('colors/safe'),
|
|
Table = require('cli-table3'),
|
|
format = require('util').format,
|
|
|
|
util = require('../../util'),
|
|
cliUtils = require('./cli-utils'),
|
|
print = require('../../print'),
|
|
pad = cliUtils.padLeft,
|
|
|
|
LF = '\n',
|
|
SPC = ' ',
|
|
DOT = '.',
|
|
E = '',
|
|
|
|
CACHED_TIMING_PHASE = '(cache)',
|
|
TIMING_TABLE_HEADERS = {
|
|
prepare: 'prepare',
|
|
wait: 'wait',
|
|
dns: 'dns-lookup',
|
|
tcp: 'tcp-handshake',
|
|
secureHandshake: 'ssl-handshake',
|
|
firstByte: 'transfer-start',
|
|
download: 'download',
|
|
process: 'process',
|
|
total: 'total'
|
|
},
|
|
BODY_CLIP_SIZE = 2048,
|
|
|
|
PostmanCLIReporter,
|
|
timestamp,
|
|
extractSNR;
|
|
|
|
// sets theme for colors for console logging
|
|
colors.setTheme({
|
|
log: 'grey',
|
|
info: 'cyan',
|
|
warn: 'yellow',
|
|
debug: 'blue',
|
|
error: 'red'
|
|
});
|
|
|
|
extractSNR = function (executions) {
|
|
var snr;
|
|
|
|
// eslint-disable-next-line lodash/collection-method-value
|
|
_.isArray(executions) && _.forEachRight(executions, function (execution) {
|
|
var nextReq = _.get(execution, 'result.return.nextRequest');
|
|
|
|
if (nextReq) {
|
|
snr = nextReq;
|
|
|
|
return false;
|
|
}
|
|
});
|
|
|
|
return snr;
|
|
};
|
|
|
|
/**
|
|
* CLI reporter
|
|
*
|
|
* @param {EventEmitter} emitter - An EventEmitter instance with event handler attachers to trigger reporting.
|
|
* @param {Object} reporterOptions - CLI reporter options object.
|
|
* @param {Boolean=} reporterOptions.silent - Boolean flag to turn off CLI reporting altogether, if set to true.
|
|
* @param {Boolean=} reporterOptions.noAssertions - Boolean flag to turn off assertion reporting, if set to true.
|
|
* @param {Boolean=} reporterOptions.noSuccessAssertions - Boolean flag, if true, turn off report successful assertions.
|
|
* @param {Boolean=} reporterOptions.noSummary - Boolean flag to turn off summary reporting altogether, if set to true.
|
|
* @param {Boolean=} reporterOptions.noFailures - Boolean flag to turn off failure reporting altogether, if set to true.
|
|
* @param {Boolean=} reporterOptions.noConsole - Boolean flag to turn off console logging, if set to true.
|
|
* @param {Boolean=} reporterOptions.noBanner - Boolean flag to turn off newman banner, if set to true.
|
|
* @param {Object} options - A set of generic collection run options.
|
|
* @returns {*}
|
|
*/
|
|
PostmanCLIReporter = function (emitter, reporterOptions, options) {
|
|
var currentGroup = options.collection,
|
|
inspect = cliUtils.inspector(options),
|
|
wrap = cliUtils.wrapper(),
|
|
symbols = cliUtils.symbols(options.disableUnicode);
|
|
|
|
// respect silent option to not report anything
|
|
if (reporterOptions.silent || options.silent) {
|
|
return; // we simply do not register anything!
|
|
}
|
|
|
|
// disable colors based on `noTTY`.
|
|
cliUtils.noTTY(options.color) && colors.disable();
|
|
|
|
// we register the `done` listener first so that in case user does not want to show results of collection run, we
|
|
// simply do not register the other events
|
|
emitter.on('done', function () {
|
|
// for some reason, if there is no run summary, it is unexpected and hence don't validate this
|
|
var run = this.summary.run;
|
|
|
|
// show the summary table (provided option does not say it is not to be shown)
|
|
if (!reporterOptions.noSummary) {
|
|
print(LF + PostmanCLIReporter.parseStatistics(run.stats, run.timings, run.transfers, options) + LF);
|
|
}
|
|
|
|
// show the failures table (provided option does not say it is not to be shown)
|
|
if (!reporterOptions.noFailures && run.failures && run.failures.length) {
|
|
print(LF + PostmanCLIReporter.parseFailures(run.failures) + LF);
|
|
}
|
|
});
|
|
|
|
emitter.on('start', function () {
|
|
var collectionIdentifier = currentGroup && (currentGroup.name || currentGroup.id);
|
|
|
|
if (!reporterOptions.noBanner) {
|
|
// print the newman banner
|
|
print('%s\n\n', colors.reset('newman'));
|
|
}
|
|
|
|
// print the collection name and newman info line
|
|
collectionIdentifier && print.lf('%s', colors.reset(collectionIdentifier));
|
|
});
|
|
|
|
emitter.on('beforeIteration', function (err, o) {
|
|
if (err || o.cursor.cycles <= 1) {
|
|
return; // do not print iteration banner if it is a single iteration run
|
|
}
|
|
|
|
// print the iteration info line
|
|
print.lf(LF + colors.gray.underline('Iteration %d/%d'), o.cursor.iteration + 1, o.cursor.cycles);
|
|
});
|
|
|
|
emitter.on('test', function (err, o) {
|
|
if (err) {
|
|
return;
|
|
}
|
|
var snr = extractSNR(o.executions);
|
|
|
|
if (snr) {
|
|
print.lf(LF + colors.gray('Attempting to set next request to', snr));
|
|
}
|
|
});
|
|
|
|
emitter.on('beforeItem', function (err, o) {
|
|
if (err) { return; }
|
|
|
|
var itemGroup = o.item.parent(),
|
|
root = !itemGroup || (itemGroup === options.collection);
|
|
|
|
// in case this item belongs to a separate folder, print that folder name
|
|
if (itemGroup && (currentGroup !== itemGroup)) {
|
|
!root && print('\n%s %s', symbols.folder, colors.reset(util.getFullName(itemGroup)));
|
|
|
|
// set the flag that keeps track of the currently running group
|
|
currentGroup = itemGroup;
|
|
}
|
|
|
|
// we print the item name. the symbol prefix denotes if the item is in root or under folder.
|
|
// @todo - when we do indentation, we would not need symbolic representation
|
|
o.item && print.lf('\n%s %s', (root ?
|
|
symbols.root : symbols.sub), colors.reset(o.item.name || E));
|
|
});
|
|
|
|
// print out the request name to be executed and start a spinner
|
|
emitter.on('beforeRequest', function (err, o) {
|
|
if (err || !o.request) { return; }
|
|
|
|
if (reporterOptions.showTimestamps) {
|
|
var currentTime = new Date();
|
|
|
|
timestamp = '[' + currentTime.toLocaleString() + ']';
|
|
print(' %s %s %s ',
|
|
colors.gray(timestamp),
|
|
colors.gray(o.request.method),
|
|
colors.gray(o.request.url.toString()));
|
|
}
|
|
else {
|
|
print(' %s %s ',
|
|
colors.gray(o.request.method),
|
|
colors.gray(o.request.url.toString()));
|
|
}
|
|
|
|
!options.disableUnicode && print().wait(colors.gray);
|
|
});
|
|
|
|
// output the response code, reason and time
|
|
emitter.on('request', function (err, o) {
|
|
if (err) {
|
|
print.lf(colors.red('[errored]'));
|
|
print.lf(colors.red(' %s'), err.message);
|
|
|
|
return;
|
|
}
|
|
|
|
if (!(o.request && o.response)) {
|
|
print.lf(colors.red('[errored]'));
|
|
print.lf(colors.red(' %s'), 'Internal error! Could not read response data.');
|
|
|
|
return;
|
|
}
|
|
|
|
// quickly print out basic non verbose response meta and exit
|
|
if (!options.verbose) {
|
|
print.lf(colors.gray('[%d %s, %s, %s]'), o.response.code, o.response.reason(),
|
|
util.filesize(o.response.size().total), util.prettyms(o.response.responseTime));
|
|
|
|
return;
|
|
}
|
|
|
|
// this point onwards the output is verbose. a tonne of variables are created here for
|
|
// keeping the output clean and readable
|
|
|
|
let req = o.request,
|
|
res = o.response,
|
|
|
|
// set values here with abundance of caution to avoid erroring out
|
|
reqSize = util.filesize(req.size().total),
|
|
resSize = util.filesize(res.size().total),
|
|
code = res.code,
|
|
reason = res.reason(),
|
|
mime = res.contentInfo() || {},
|
|
timings = _.last(_.get(o, 'history.execution.data')),
|
|
|
|
reqHeadersLen = _.get(req, 'headers.members.length'),
|
|
resHeadersLen = _.get(res, 'headers.members.length'),
|
|
|
|
resTime = util.prettyms(res.responseTime || 0),
|
|
|
|
reqText = (options.verbose && req.body) ? req.body.toString() : E,
|
|
reqTextLen = req.size().body || Buffer.byteLength(reqText),
|
|
|
|
resText = options.verbose ? res.text() : E,
|
|
resTextLen = res.size().body || Buffer.byteLength(resText),
|
|
|
|
reqBodyMode = _.get(req, 'body.mode', ''),
|
|
resSummary = [
|
|
`${mime.contentType}`,
|
|
`${mime.mimeType}`,
|
|
`${mime.mimeFormat}`,
|
|
`${mime.charset}`
|
|
].join(` ${colors.gray(symbols.star)} `);
|
|
|
|
|
|
print.lf(SPC); // also flushes out the circling progress icon
|
|
|
|
// for clean readability of code. this section compiles the cli string for one line of
|
|
// req-res combined summary. this looks somewhat like below:
|
|
// >> 200 OK ★ 979ms time ★ 270B↑ 793B↓ size ★ 7↑ 7↓ headers ★ 0 cookies
|
|
print.lf(SPC + SPC + [
|
|
`${code} ${reason}`,
|
|
`${resTime} ${colors.gray('time')}`,
|
|
`${reqSize}${colors.gray(symbols.up)} ${resSize}${colors.gray(symbols.down)} ${colors.gray('size')}`,
|
|
`${reqHeadersLen}${colors.gray(symbols.up)} ` +
|
|
`${resHeadersLen}${colors.gray(symbols.down)} ${colors.gray('headers')}`,
|
|
`${_.get(res, 'cookies.members.length')} ${colors.gray('cookies')}`
|
|
].join(` ${colors.gray(symbols.star)} `));
|
|
|
|
// print request body
|
|
if (reqTextLen) {
|
|
// truncate very large request (is 2048 large enough?)
|
|
if (reqTextLen > BODY_CLIP_SIZE) {
|
|
reqText = reqText.substr(0, BODY_CLIP_SIZE) +
|
|
colors.brightWhite(`\n(showing ${util.filesize(BODY_CLIP_SIZE)}/${util.filesize(reqTextLen)})`);
|
|
}
|
|
|
|
reqText = wrap(reqText, ` ${colors.white(symbols.console.middle)} `);
|
|
// eslint-disable-next-line max-len
|
|
print.buffer(` ${colors.white(symbols.console.top)} ${colors.white(symbols.up)} ${reqBodyMode} ${colors.gray(symbols.star)} ${util.filesize(reqTextLen)}\n`,
|
|
colors.white(` ${symbols.console.bottom}`))
|
|
// tweak the message to ensure that its surrounding is not brightly coloured.
|
|
// also ensure to remove any blank lines generated due to util.inspect
|
|
.nobuffer(colors.gray(reqText.replace(/\n\s*\n/g, LF) + LF));
|
|
|
|
print.lf(SPC); // visual tweak: flushes out the buffer of wrapping body above
|
|
}
|
|
|
|
// print response body
|
|
if (resTextLen) {
|
|
// truncate very large response (is 2048 large enough?)
|
|
if (resTextLen > BODY_CLIP_SIZE) {
|
|
resText = resText.substr(0, BODY_CLIP_SIZE) +
|
|
colors.brightWhite(`\n(showing ${util.filesize(BODY_CLIP_SIZE)}/${util.filesize(resTextLen)})`);
|
|
}
|
|
|
|
resText = wrap(resText, ` ${colors.white(symbols.console.middle)} `);
|
|
// eslint-disable-next-line max-len
|
|
print.buffer(` ${colors.white(symbols.console.top)} ${colors.white(symbols.down)} ${resSummary} ${colors.gray(symbols.star)} ${util.filesize(resTextLen)}\n`,
|
|
colors.white(` ${symbols.console.bottom}`))
|
|
// tweak the message to ensure that its surrounding is not brightly coloured.
|
|
// also ensure to remove any blank lines generated due to util.inspect
|
|
.nobuffer(colors.gray(resText.replace(/\n\s*\n/g, LF) + LF));
|
|
}
|
|
// print the line of response body meta one liner if there is no response body
|
|
// if there is one, we would already print it across the body braces above.
|
|
else {
|
|
// we need to do some newline related shenanigans here so that the output looks clean
|
|
// in the absence of the request body block
|
|
print.lf(` ${symbols.down} ${resSummary}`);
|
|
}
|
|
|
|
// print timing info of the request
|
|
timings = timings && timings.timings; // if there are redirects, get timings for the last request sent
|
|
if (timings) {
|
|
// adds nice units to all time data in the object
|
|
let timingPhases = util.beautifyTime(sdk.Response.timingPhases(timings)),
|
|
timingTable = new Table({
|
|
chars: _.defaults({ mid: '', middle: '' }, cliUtils.cliTableTemplate_Blank),
|
|
colAligns: _.fill(Array(_.size(timingPhases)), 'left'),
|
|
style: { 'padding-left': 2 }
|
|
});
|
|
|
|
timingPhases = _.transform(TIMING_TABLE_HEADERS, (result, header, key) => {
|
|
if (_.has(timingPhases, key)) {
|
|
result.headers.push(colors.white(header));
|
|
result.values.push(colors.log(timingPhases[key] || CACHED_TIMING_PHASE));
|
|
}
|
|
}, { headers: [], values: [] });
|
|
|
|
|
|
timingTable.push(timingPhases.headers); // add name of phases in the table
|
|
timingTable.push(timingPhases.values); // add time of phases in the table
|
|
|
|
print(LF + timingTable + LF + LF);
|
|
}
|
|
});
|
|
|
|
// Print script errors in real time
|
|
emitter.on('script', function (err, o) {
|
|
err && print.lf(colors.red.bold('%s⠄ %s in %s-script'), pad(this.summary.run.failures.length, 3, SPC), err.name,
|
|
o.event && o.event.listen || 'unknown');
|
|
});
|
|
|
|
!reporterOptions.noAssertions && emitter.on('assertion', function (err, o) {
|
|
var passed = !err;
|
|
|
|
// handle skipped test display
|
|
if (o.skipped && !reporterOptions.noSuccessAssertions) {
|
|
print.lf('%s %s', colors.cyan(' - '), colors.cyan('[skipped] ' + o.assertion));
|
|
|
|
return;
|
|
}
|
|
|
|
if (passed && reporterOptions.noSuccessAssertions) {
|
|
return;
|
|
}
|
|
|
|
// print each test assertions
|
|
if (reporterOptions.showTimestamps) {
|
|
timestamp = '[' + new Date().toLocaleTimeString() + ']';
|
|
print.lf(' %s%s %s', colors.gray(timestamp), passed ? colors.green(` ${symbols.ok} `) :
|
|
colors.red.bold(pad(this.summary.run.failures.length, 2, SPC) + symbols.dot), passed ?
|
|
colors.gray(o.assertion) : colors.red.bold(o.assertion));
|
|
}
|
|
else {
|
|
print.lf('%s %s', passed ? colors.green(` ${symbols.ok} `) :
|
|
colors.red.bold(pad(this.summary.run.failures.length, 3, SPC) + symbols.dot), passed ?
|
|
colors.gray(o.assertion) : colors.red.bold(o.assertion));
|
|
}
|
|
});
|
|
|
|
// show user console logs in a neatly formatted way (provided user has not disabled the same)
|
|
!reporterOptions.noConsole && emitter.on('console', function (err, o) {
|
|
if (err) { return; }
|
|
|
|
var color = colors[o.level] || colors.gray,
|
|
message;
|
|
|
|
// we first merge all messages to a string. while merging we run the values to util.inspect to colour code the
|
|
// messages based on data type
|
|
message = wrap(_.reduce(o.messages, function (log, message) { // wrap the whole message to the window size
|
|
return (log += (log ? colors.white(', ') : '') + inspect(message));
|
|
}, E), ` ${color(symbols.console.middle)} `); // add an indentation line at the beginning
|
|
|
|
// print the timestamp if the falg is present
|
|
if (reporterOptions.showTimestamps) {
|
|
print(LF + ' %s', colors.gray('[' + new Date().toLocaleTimeString() + ']' + LF));
|
|
}
|
|
|
|
print.buffer(color(` ${symbols.console.top}\n`), color(` ${symbols.console.bottom}\n`))
|
|
// tweak the message to ensure that its surrounding is not brightly coloured.
|
|
// also ensure to remove any blank lines generated due to util.inspect
|
|
.nobuffer(colors.gray(message.replace(/\n\s*\n/g, LF) + LF));
|
|
});
|
|
};
|
|
|
|
_.assignIn(PostmanCLIReporter, {
|
|
|
|
// @todo: change function signature to accept run object and options, thereby reducing parameters
|
|
/**
|
|
* A CLI reporter method to parse collection run statistics into a CLI table.
|
|
*
|
|
* @param {Object} stats - The cumulative collection run status object.
|
|
* @param {Object} stats.iterations - A set of values for total, pending, and failed iterations.
|
|
* @param {Number} stats.iterations.total - Total iterations in the current collection run.
|
|
* @param {Number} stats.iterations.pending - Pending iterations in the current collection run.
|
|
* @param {Number} stats.iterations.failed - Failed iterations in the current collection run.
|
|
* @param {Object} stats.requests - A set of values for total, pending, and failed requests.
|
|
* @param {Number} stats.requests.total - Total requests in the current collection run.
|
|
* @param {Number} stats.requests.pending - Pending requests in the current collection run.
|
|
* @param {Number} stats.requests.failed - Failed requests in the current collection run.
|
|
* @param {Object} stats.testScripts - A set of values for total, pending, and failed testScripts.
|
|
* @param {Number} stats.testScripts.total - Total testScripts in the current collection run.
|
|
* @param {Number} stats.testScripts.pending - Pending testScripts in the current collection run.
|
|
* @param {Number} stats.testScripts.failed - Failed testScripts in the current collection run.
|
|
* @param {Object} stats.prerequestScripts - A set of values for total, pending, and failed prerequestScripts.
|
|
* @param {Number} stats.prerequestScripts.total - Total prerequestScripts in the current collection run.
|
|
* @param {Number} stats.prerequestScripts.pending - Pending prerequestScripts in the current collection run.
|
|
* @param {Number} stats.prerequestScripts.failed - Failed prerequestScripts in the current collection run.
|
|
* @param {Object} stats.assertions - A set of values for total, pending, and failed assertions.
|
|
* @param {Number} stats.assertions.total - Total assertions in the current collection run.
|
|
* @param {Number} stats.assertions.pending - Pending assertions in the current collection run.
|
|
* @param {Number} stats.assertions.failed - Failed assertions in the current collection run.
|
|
* @param {Object} timings - A set of values for the timings of the current collection run.
|
|
* @param {Number} timings.completed - The end timestamp for the current collection run.
|
|
* @param {Number} timings.started - The start timestamp for the current collection run
|
|
* @param {String} timings.responseAverage - The average response time across all requests
|
|
* @param {String} timings.responseMin - The minimum response time across all requests
|
|
* @param {String} timings.responseMax - The maximum response time across all requests
|
|
* @param {String} timings.responseSd - Standard deviation of response time across all requests
|
|
* @param {String} timings.dnsAverage - The average DNS lookup time of the run
|
|
* @param {String} timings.dnsMin - The minimum DNS lookup time of the run
|
|
* @param {String} timings.dnsMax - The maximum DNS lookup time of the run
|
|
* @param {String} timings.dnsSd - Standard deviation of DNS lookup time of the run
|
|
* @param {String} timings.firstByteAverage - The average first byte time of the run
|
|
* @param {String} timings.firstByteMin - The minimum first byte time of the run
|
|
* @param {String} timings.firstByteMax - The maximum first byte time of the run
|
|
* @param {String} timings.firstByteSd - Standard deviation of first byte time of the run
|
|
* @param {Object} transfers - A set of details on the network usage for the current collection run.
|
|
* @param {String} transfers.responseTotal - The net extent of the data transfer achieved during the collection run.
|
|
* @param {Object} options - The set of generic collection run options.
|
|
* @returns {Table} - The constructed collection run statistics table.
|
|
*/
|
|
parseStatistics (stats, timings, transfers, options) {
|
|
var summaryTable;
|
|
|
|
// create the summary table
|
|
summaryTable = new Table({
|
|
chars: options.disableUnicode && cliUtils.cliTableTemplateFallback,
|
|
style: { head: [] },
|
|
head: [E, 'executed', ' failed'],
|
|
colAligns: ['right', 'right', 'right'],
|
|
colWidths: [25]
|
|
});
|
|
|
|
// add specific rows to show in summary
|
|
stats && _.forEach([{
|
|
source: 'iterations',
|
|
label: 'iterations'
|
|
}, {
|
|
source: 'requests',
|
|
label: 'requests'
|
|
}, {
|
|
source: 'testScripts',
|
|
label: 'test-scripts'
|
|
}, {
|
|
source: 'prerequestScripts',
|
|
label: 'prerequest-scripts'
|
|
}, {
|
|
source: 'assertions',
|
|
label: 'assertions'
|
|
}], function (row) {
|
|
var metric = stats[row.source],
|
|
label = row.label;
|
|
|
|
// colour the label based on the failure or pending count of the metric
|
|
label = metric.failed ? colors.red(label) : (metric.pending ? label : colors.green(label));
|
|
|
|
// push the statistics
|
|
summaryTable.push([
|
|
label,
|
|
metric.total,
|
|
(metric.failed ? colors.red(metric.failed) : metric.failed)
|
|
// @todo - add information of pending scripts
|
|
// (metric.failed ? colors.red(metric.failed) : metric.failed) +
|
|
// (metric.pending ? format(' (%d pending)', metric.pending) : E)
|
|
]);
|
|
});
|
|
|
|
// add the total execution time to summary
|
|
timings && summaryTable.push([{
|
|
colSpan: 3,
|
|
content: format('total run duration: %s', util.prettyms(timings.completed - timings.started)),
|
|
hAlign: 'left' // since main style was set to right
|
|
}]);
|
|
|
|
// add row to show total data received
|
|
transfers && summaryTable.push([{
|
|
colSpan: 3,
|
|
content: format('total data received: %s (approx)', util.filesize(transfers.responseTotal)),
|
|
hAlign: 'left'
|
|
}]);
|
|
|
|
// add rows containing average time of different request phases
|
|
timings && _.forEach({
|
|
response: 'average response time:',
|
|
dns: 'average DNS lookup time:',
|
|
firstByte: 'average first byte time:'
|
|
}, (value, key) => {
|
|
timings[`${key}Average`] && summaryTable.push([{
|
|
colSpan: 3,
|
|
content: format(`${value} %s [min: %s, max: %s, s.d.: %s]`,
|
|
util.prettyms(timings[`${key}Average`]),
|
|
util.prettyms(timings[`${key}Min`]),
|
|
util.prettyms(timings[`${key}Max`]),
|
|
util.prettyms(timings[`${key}Sd`])),
|
|
hAlign: 'left'
|
|
}]);
|
|
});
|
|
|
|
return summaryTable;
|
|
},
|
|
|
|
/**
|
|
* A CLI reporter method to parse collection run failure statistics into a CLI table.
|
|
*
|
|
* @param {Array} failures - An array of failure objects.
|
|
* @returns {Table} - The constructed CLI failure Table object.
|
|
*/
|
|
parseFailures (failures) {
|
|
var failureTable = new Table({
|
|
head: [{
|
|
hAlign: 'right',
|
|
content: colors.red.underline('#')
|
|
}, colors.red.underline('failure'),
|
|
colors.red.underline('detail')],
|
|
chars: cliUtils.cliTableTemplate_Blank,
|
|
wordWrap: true,
|
|
colAligns: ['right'],
|
|
colWidths: cliUtils.noTTY() ? [] : (function (size, indexOrder) {
|
|
var colWidths = [];
|
|
|
|
if (size.exists && size.width && (size.width > 20)) {
|
|
colWidths[0] = indexOrder + 3;
|
|
colWidths[1] = parseInt((size.width - colWidths[0]) * 0.2, 10);
|
|
colWidths[2] = parseInt(size.width - (colWidths[0] + colWidths[1] + 5), 10);
|
|
}
|
|
|
|
return colWidths;
|
|
}(cliUtils.dimension(), Number(failures.length.toString().length)))
|
|
});
|
|
|
|
_.forEach(failures, function (failure, index) {
|
|
var name = failure.error && failure.error.name || E,
|
|
message = failure.error && failure.error.test || E;
|
|
|
|
// augment name with iteration information
|
|
failure.cursor && (failure.cursor.cycles > 1) &&
|
|
(name += LF + colors.gray('iteration: ' + (failure.cursor.iteration + 1)));
|
|
|
|
// include the assertion error message in the failure details
|
|
failure.error && (message += LF + colors.gray(failure.error.message || E));
|
|
|
|
// augment the message with stack information
|
|
failure.at && (message += LF + colors.gray('at ' + failure.at));
|
|
|
|
// augment message with item information
|
|
failure.source &&
|
|
(message += format(colors.gray('\ninside "%s"'), util.getFullName(failure.source)));
|
|
|
|
failureTable.push([pad(Number(index + 1), Number(failures.length.toString().length)).toString() +
|
|
DOT, name, message]);
|
|
});
|
|
|
|
return failureTable;
|
|
}
|
|
});
|
|
|
|
// Mark the CLI reporter as dominant, so that no two dominant reporters are together
|
|
PostmanCLIReporter.prototype.dominant = true;
|
|
|
|
module.exports = PostmanCLIReporter;
|