@redocly/respect-core/lib/modules/logger-output/display-checks.js

API testing framework core

import { blue, yellow, green, gray, red } from 'colorette';
import { isBrowser } from '@redocly/openapi-core';
import { outdent } from 'outdent';
import { combineUrl } from '../../utils/url.js';
import { isJSON } from '../../utils/is-json.js';
import { indent, RESET_ESCAPE_CODE } from './helpers.js';
const MAX_CRITERIA_CONDITION_DISPLAY_LENGTH = 50;
export function displayChecks({ testNameToDisplay, checks, verboseLogs, verboseResponseLogs, logger, }) {
    const allChecksPassed = checks.every(({ passed }) => passed);
    logger.output(`  ${allChecksPassed ? green('✓') : red('✗')} ${blue(testNameToDisplay)}`);
    if (verboseLogs) {
        logger.output(`${RESET_ESCAPE_CODE}\n` + (displayVerboseLogs({ logs: verboseLogs, logger }) || ''));
        logger.printNewLine();
    }
    if (verboseResponseLogs) {
        logger.output(`${RESET_ESCAPE_CODE}\n` +
            (displayVerboseLogs({ logs: verboseResponseLogs, type: 'response', logger }) || ''));
        logger.printNewLine();
    }
    logger.printNewLine();
    for (const check of checks) {
        logger.output(`${indent(displayCheckInfo(check, check.severity), 4)}\n`);
    }
}
function displayCheckInfo(check, severity) {
    const { name: checkName, passed, condition } = check;
    const icon = passed ? green('✓') : severity === 'warn' ? yellow('⚠') : red('✗');
    const color = passed ? green : red;
    return `${icon} ${gray(checkName.toLowerCase())}${condition
        ? ` - ${color(condition.length > MAX_CRITERIA_CONDITION_DISPLAY_LENGTH
            ? condition.slice(0, MAX_CRITERIA_CONDITION_DISPLAY_LENGTH) + '...'
            : condition)}`
        : ''}`;
}
function displayVerboseLogs({ logs, type = 'request', logger, }) {
    const { path, host, headerParams, body, statusCode } = logs;
    const responseTime = !isBrowser && process.env.NODE_ENV === 'test' ? '<test>' : logs.responseTime;
    const responseSize = !isBrowser && process.env.NODE_ENV === 'test' ? '<test>' : logs.responseSize;
    const urlString = indent(`Request URL: ${blue(combineUrl(host, path))}`, 4);
    const requestHeadersString = indent(`Request Headers:`, 4);
    const responseHeadersString = indent(`Response Headers:`, 4);
    const requestBodyString = indent(`Request Body:`, 4);
    const responseBodyString = indent(`Response Body:`, 4);
    const headersString = generateHeaderString(headerParams || {});
    let formattedBody;
    if (body instanceof FormData) {
        // Convert FormData to a simple object for display
        const formDataObject = {};
        for (const [key, value] of body.entries()) {
            if (value instanceof File) {
                formDataObject[key] = `[File: ${value.name}]`;
            }
            else {
                formDataObject[key] = value;
            }
        }
        formattedBody = JSON.stringify(formDataObject, null, 2);
    }
    else if (body && isJSON(body)) {
        formattedBody = JSON.stringify(JSON.parse(body), null, 2);
    }
    else if (body instanceof File) {
        formattedBody = `[File: ${body.name}]`;
    }
    else if (body instanceof ArrayBuffer) {
        formattedBody = `[Binary: ${body.byteLength} bytes]`;
    }
    else {
        formattedBody = body;
    }
    const indentedBody = formattedBody
        ? formattedBody
            .split('\n')
            .map((line) => blue(indent(`${line}`, 6)))
            .join('\n')
        : undefined;
    const bodyString = indentedBody;
    const requestOutput = [
        logger.printNewLine(),
        gray(urlString),
        headersString && gray(requestHeadersString),
        headersString && gray(headersString),
        body && gray(requestBodyString),
        body && bodyString,
    ]
        .filter(Boolean)
        .join(`${RESET_ESCAPE_CODE}\n`);
    const responseOutput = [
        gray(indent('Response status code: ' + blue(statusCode), 4)),
        gray(indent('Response time: ' + blue(responseTime), 4) + ' ms'),
        !isBrowser && process.env.NODE_ENV === 'test'
            ? gray(indent('Response Headers: <response headers test>', 4))
            : headersString && gray(responseHeadersString) + '\n' + gray(headersString),
        responseSize && gray(indent('Response Size: ' + blue(responseSize), 4) + ' bytes'),
        body && gray(responseBodyString),
        body && bodyString,
    ]
        .filter(Boolean)
        .join(`${RESET_ESCAPE_CODE}\n`);
    return type === 'request' ? outdent `${requestOutput}` : outdent `${responseOutput}`;
}
function generateHeaderString(headerParams) {
    let compiledString = '';
    const entries = Object.entries(headerParams);
    entries.forEach(([key, value], index) => {
        compiledString = compiledString + indent(`${yellow(key)}: ${blue(value)}`, 6);
        if (index < entries.length - 1) {
            compiledString += `${RESET_ESCAPE_CODE}\n`;
        }
    });
    return compiledString;
}
//# sourceMappingURL=display-checks.js.map