norn-cli 1.6.1 → 1.6.2

package/out/assertionRunner.js

@@ -1,537 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAssertCommand = isAssertCommand;
-exports.parseAssertCommand = parseAssertCommand;
-exports.resolveValue = resolveValue;
-exports.evaluateAssertion = evaluateAssertion;
-const schemaGenerator_1 = require("./schemaGenerator");
-/**
- * Checks if a line is an assert command
- */
-function isAssertCommand(line) {
-    return /^assert\s+/i.test(line.trim());
-}
-/**
- * Parses an assert command line.
- *
- * Supported formats:
- * - assert $1.status == 200
- * - assert $1.body.name == "John"
- * - assert $1.body.email contains "@"
- * - assert $1.body.token exists
- * - assert $1.status >= 200 | "Should return success status"
- *
- * @param line The assert command line
- * @returns Parsed assertion or null if invalid
- */
-function parseAssertCommand(line) {
-    const trimmed = line.trim();
-    const match = trimmed.match(/^assert\s+(.+)$/i);
-    if (!match) {
-        return null;
-    }
-    let content = match[1].trim();
-    let message;
-    // Check for optional message after |
-    const pipeIndex = findUnquotedPipe(content);
-    if (pipeIndex !== -1) {
-        message = content.substring(pipeIndex + 1).trim();
-        // Remove surrounding quotes from message if present
-        if ((message.startsWith('"') && message.endsWith('"')) ||
-            (message.startsWith("'") && message.endsWith("'"))) {
-            message = message.slice(1, -1);
-        }
-        content = content.substring(0, pipeIndex).trim();
-    }
-    // Try to parse unary operators first (exists, !exists)
-    const existsMatch = content.match(/^(.+?)\s+(exists|!exists)$/i);
-    if (existsMatch) {
-        return {
-            leftExpr: existsMatch[1].trim(),
-            operator: existsMatch[2].toLowerCase(),
-            message
-        };
-    }
-    // Parse binary operators
-    // Order matters: check multi-char operators first
-    const binaryOperators = [
-        { pattern: /^(.+?)\s*>=\s*(.+)$/, op: '>=' },
-        { pattern: /^(.+?)\s*<=\s*(.+)$/, op: '<=' },
-        { pattern: /^(.+?)\s*==\s*(.+)$/, op: '==' },
-        { pattern: /^(.+?)\s*!=\s*(.+)$/, op: '!=' },
-        { pattern: /^(.+?)\s*>\s*(.+)$/, op: '>' },
-        { pattern: /^(.+?)\s*<\s*(.+)$/, op: '<' },
-        { pattern: /^(.+?)\s+contains\s+(.+)$/i, op: 'contains' },
-        { pattern: /^(.+?)\s+startsWith\s+(.+)$/i, op: 'startsWith' },
-        { pattern: /^(.+?)\s+endsWith\s+(.+)$/i, op: 'endsWith' },
-        { pattern: /^(.+?)\s+matches\s+(.+)$/i, op: 'matches' },
-        { pattern: /^(.+?)\s+matchesSchema\s+(.+)$/i, op: 'matchesSchema' },
-        { pattern: /^(.+?)\s+isType\s+(.+)$/i, op: 'isType' },
-    ];
-    for (const { pattern, op } of binaryOperators) {
-        const binaryMatch = content.match(pattern);
-        if (binaryMatch) {
-            return {
-                leftExpr: binaryMatch[1].trim(),
-                operator: op,
-                rightExpr: binaryMatch[2].trim(),
-                message
-            };
-        }
-    }
-    return null;
-}
-/**
- * Find the index of an unquoted pipe character
- */
-function findUnquotedPipe(str) {
-    let inQuote = false;
-    let quoteChar = '';
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        if ((char === '"' || char === "'") && !inQuote) {
-            inQuote = true;
-            quoteChar = char;
-        }
-        else if (char === quoteChar && inQuote) {
-            inQuote = false;
-            quoteChar = '';
-        }
-        else if (char === '|' && !inQuote) {
-            return i;
-        }
-    }
-    return -1;
-}
-/**
- * Resolves a value expression to its actual value.
- *
- * Supports:
- * - $N.path references (e.g., $1.status, $1.body.user.id)
- * - String literals ("hello" or 'hello')
- * - Number literals (200, 3.14)
- * - Boolean literals (true, false)
- * - null
- * - Variable references {{varName}}
- *
- * @param expr The expression to resolve
- * @param responses Array of responses from the sequence (indexed by $N where N is 1-based)
- * @param variables Current runtime variables
- * @param getValueByPath Function to extract value from response
- * @param responseIndexToVariable Optional mapping from response index to variable name
- */
-function resolveValue(expr, responses, variables, getValueByPath, responseIndexToVariable) {
-    const trimmed = expr.trim();
-    // Check for $N.path reference
-    const refMatch = trimmed.match(/^\$(\d+)\.(.+)$/);
-    if (refMatch) {
-        const responseIdx = parseInt(refMatch[1], 10); // Keep 1-based for tracking
-        const responseIndex = responseIdx - 1; // Convert to 0-based for array access
-        const path = refMatch[2];
-        if (responseIndex < 0 || responseIndex >= responses.length) {
-            return {
-                value: undefined,
-                error: `Response $${refMatch[1]} does not exist (only ${responses.length} responses so far)`
-            };
-        }
-        const response = responses[responseIndex];
-        const value = getValueByPath(response, path);
-        return {
-            value,
-            responseIndex: responseIdx,
-            response,
-            jsonPath: path,
-            variableName: responseIndexToVariable?.get(responseIdx)
-        };
-    }
-    // Check for $N without path (invalid in new syntax)
-    if (/^\$\d+$/.test(trimmed)) {
-        return {
-            value: undefined,
-            error: `Invalid reference: ${trimmed}. Use $N.body for full body or $N.status, $N.headers, etc.`
-        };
-    }
-    // Check for variable.path reference (e.g., user.body.username where user is a captured response)
-    const varPathMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])+)$/);
-    if (varPathMatch) {
-        const varName = varPathMatch[1];
-        const pathPart = varPathMatch[2];
-        if (varName in variables) {
-            const varValue = variables[varName];
-            // If the variable is an object (like HttpResponse), navigate the path
-            if (typeof varValue === 'object' && varValue !== null) {
-                const path = pathPart.replace(/^\./, ''); // Remove leading dot
-                const value = getNestedValue(varValue, path);
-                // Check if this looks like an HttpResponse (has status and body)
-                const isHttpResponse = 'status' in varValue && 'body' in varValue;
-                return {
-                    value,
-                    variableName: varName,
-                    jsonPath: path,
-                    response: isHttpResponse ? varValue : undefined
-                };
-            }
-            // If it's a string, try to parse as JSON
-            if (typeof varValue === 'string') {
-                try {
-                    const parsed = JSON.parse(varValue);
-                    const path = pathPart.replace(/^\./, '');
-                    const value = getNestedValue(parsed, path);
-                    return { value, variableName: varName, jsonPath: path };
-                }
-                catch {
-                    return { value: undefined, error: `Cannot access path on non-object variable: ${varName}` };
-                }
-            }
-        }
-        return { value: undefined, error: `Variable '${varName}' is not defined` };
-    }
-    // Check for simple variable reference (no path) - e.g., just "user" or "token"
-    const simpleVarMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
-    if (simpleVarMatch) {
-        const varName = simpleVarMatch[1];
-        // Don't treat type keywords as variables
-        if (!['true', 'false', 'null', 'string', 'number', 'boolean', 'object', 'array', 'undefined'].includes(varName.toLowerCase())) {
-            if (varName in variables) {
-                const varValue = variables[varName];
-                // Try to parse numbers
-                if (typeof varValue === 'string' && /^-?\d+(\.\d+)?$/.test(varValue)) {
-                    return { value: parseFloat(varValue) };
-                }
-                return { value: varValue };
-            }
-            // Variable not found - but could also be a type name for isType, so don't error here
-        }
-    }
-    // Check for variable reference {{varName}}
-    const varMatch = trimmed.match(/^\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}$/);
-    if (varMatch) {
-        const varName = varMatch[1];
-        if (varName in variables) {
-            // Try to parse as number if it looks like one
-            const varValue = variables[varName];
-            if (typeof varValue === 'string' && /^-?\d+(\.\d+)?$/.test(varValue)) {
-                return { value: parseFloat(varValue) };
-            }
-            return { value: varValue };
-        }
-        return { value: undefined, error: `Variable {{${varName}}} is not defined` };
-    }
-    // Check for string literal
-    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-        return { value: trimmed.slice(1, -1) };
-    }
-    // Check for number literal
-    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-        return { value: parseFloat(trimmed) };
-    }
-    // Check for boolean literals
-    if (trimmed.toLowerCase() === 'true') {
-        return { value: true };
-    }
-    if (trimmed.toLowerCase() === 'false') {
-        return { value: false };
-    }
-    // Check for null
-    if (trimmed.toLowerCase() === 'null') {
-        return { value: null };
-    }
-    // Check for empty array literal
-    if (trimmed === '[]') {
-        return { value: [] };
-    }
-    // Check for empty object literal
-    if (trimmed === '{}') {
-        return { value: {} };
-    }
-    // Unknown expression type
-    return { value: undefined, error: `Cannot resolve expression: ${trimmed}` };
-}
-/**
- * Helper function to get nested value from an object using dot notation path
- */
-function getNestedValue(obj, path) {
-    if (!path || obj === null || obj === undefined) {
-        return obj;
-    }
-    // Convert [0] to .0 and split by dots
-    const parts = path.replace(/\[(\d+)\]/g, '.$1').split('.').filter(p => p !== '');
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || current === undefined) {
-            return undefined;
-        }
-        current = current[part];
-    }
-    return current;
-}
-function areValuesEqual(leftValue, rightValue) {
-    if (leftValue === rightValue) {
-        return true;
-    }
-    if (leftValue === null || rightValue === null || leftValue === undefined || rightValue === undefined) {
-        return leftValue === rightValue;
-    }
-    const leftIsArray = Array.isArray(leftValue);
-    const rightIsArray = Array.isArray(rightValue);
-    if (leftIsArray || rightIsArray) {
-        if (!leftIsArray || !rightIsArray) {
-            return false;
-        }
-        if (leftValue.length !== rightValue.length) {
-            return false;
-        }
-        for (let i = 0; i < leftValue.length; i++) {
-            if (!areValuesEqual(leftValue[i], rightValue[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    const leftIsObject = typeof leftValue === 'object';
-    const rightIsObject = typeof rightValue === 'object';
-    if (leftIsObject || rightIsObject) {
-        if (!leftIsObject || !rightIsObject) {
-            return false;
-        }
-        const leftKeys = Object.keys(leftValue);
-        const rightKeys = Object.keys(rightValue);
-        if (leftKeys.length !== rightKeys.length) {
-            return false;
-        }
-        for (const key of leftKeys) {
-            if (!Object.prototype.hasOwnProperty.call(rightValue, key)) {
-                return false;
-            }
-            if (!areValuesEqual(leftValue[key], rightValue[key])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return leftValue == rightValue;
-}
-/**
- * Evaluates an assertion.
- *
- * @param assertion Parsed assertion
- * @param responses Array of responses from the sequence
- * @param variables Current runtime variables (can contain objects like HttpResponse)
- * @param getValueByPath Function to extract value from response
- * @param responseIndexToVariable Optional mapping from response index (1-based) to variable name
- * @param basePath Optional base path for resolving relative schema file paths
- */
-function evaluateAssertion(assertion, responses, variables, getValueByPath, responseIndexToVariable, basePath) {
-    const leftResult = resolveValue(assertion.leftExpr, responses, variables, getValueByPath, responseIndexToVariable);
-    // Helper to build failure context from left result
-    const buildFailureContext = () => ({
-        responseIndex: leftResult.responseIndex,
-        friendlyName: leftResult.variableName,
-        relatedResponse: leftResult.response,
-        jsonPath: leftResult.jsonPath
-    });
-    // Handle resolution errors
-    if (leftResult.error) {
-        return {
-            passed: false,
-            expression: formatExpression(assertion),
-            message: assertion.message,
-            operator: assertion.operator,
-            leftValue: undefined,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            error: leftResult.error,
-            ...buildFailureContext()
-        };
-    }
-    const leftValue = leftResult.value;
-    // Handle unary operators
-    if (assertion.operator === 'exists') {
-        const passed = leftValue !== undefined && leftValue !== null;
-        return {
-            passed,
-            expression: formatExpression(assertion),
-            message: assertion.message,
-            operator: assertion.operator,
-            leftValue,
-            leftExpression: assertion.leftExpr,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    if (assertion.operator === '!exists') {
-        const passed = leftValue === undefined || leftValue === null;
-        return {
-            passed,
-            expression: formatExpression(assertion),
-            message: assertion.message,
-            operator: assertion.operator,
-            leftValue,
-            leftExpression: assertion.leftExpr,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    // Binary operators require right expression
-    if (!assertion.rightExpr) {
-        return {
-            passed: false,
-            expression: formatExpression(assertion),
-            message: assertion.message,
-            operator: assertion.operator,
-            leftValue,
-            leftExpression: assertion.leftExpr,
-            error: `Operator ${assertion.operator} requires a right-hand value`,
-            ...buildFailureContext()
-        };
-    }
-    // For isType operator, the right side is a literal type name, not a value to resolve
-    if (assertion.operator === 'isType') {
-        const expectedType = assertion.rightExpr.toLowerCase();
-        let actualType;
-        if (leftValue === null) {
-            actualType = 'null';
-        }
-        else if (Array.isArray(leftValue)) {
-            actualType = 'array';
-        }
-        else {
-            actualType = typeof leftValue;
-        }
-        const passed = actualType === expectedType;
-        return {
-            passed,
-            expression: formatExpression(assertion),
-            message: assertion.message,
-            operator: assertion.operator,
-            leftValue,
-            rightValue: expectedType,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    // For matchesSchema operator, validate against a JSON Schema file
-    if (assertion.operator === 'matchesSchema') {
-        // Right side is a file path (with or without quotes)
-        let schemaPath = assertion.rightExpr;
-        // Remove surrounding quotes if present
-        if ((schemaPath.startsWith('"') && schemaPath.endsWith('"')) ||
-            (schemaPath.startsWith("'") && schemaPath.endsWith("'"))) {
-            schemaPath = schemaPath.slice(1, -1);
-        }
-        const validationResult = (0, schemaGenerator_1.validateAgainstSchemaDetailed)(leftValue, schemaPath, basePath);
-        const passed = validationResult.valid;
-        return {
-            passed,
-            expression: formatExpression(assertion),
-            message: assertion.message,
-            operator: assertion.operator,
-            leftValue,
-            rightValue: schemaPath,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            error: !passed && validationResult.errorStrings ? validationResult.errorStrings.join('; ') : undefined,
-            schemaErrors: validationResult.errors,
-            schemaPath: validationResult.resolvedSchemaPath,
-            schema: validationResult.schema,
-            ...(!passed ? buildFailureContext() : {})
-        };
-    }
-    const rightResult = resolveValue(assertion.rightExpr, responses, variables, getValueByPath, responseIndexToVariable);
-    if (rightResult.error) {
-        return {
-            passed: false,
-            expression: formatExpression(assertion),
-            message: assertion.message,
-            operator: assertion.operator,
-            leftValue,
-            rightValue: undefined,
-            leftExpression: assertion.leftExpr,
-            rightExpression: assertion.rightExpr,
-            error: rightResult.error,
-            ...buildFailureContext()
-        };
-    }
-    const rightValue = rightResult.value;
-    let passed = false;
-    switch (assertion.operator) {
-        case '==':
-            passed = areValuesEqual(leftValue, rightValue);
-            break;
-        case '!=':
-            passed = !areValuesEqual(leftValue, rightValue);
-            break;
-        case '>':
-            passed = Number(leftValue) > Number(rightValue);
-            break;
-        case '>=':
-            passed = Number(leftValue) >= Number(rightValue);
-            break;
-        case '<':
-            passed = Number(leftValue) < Number(rightValue);
-            break;
-        case '<=':
-            passed = Number(leftValue) <= Number(rightValue);
-            break;
-        case 'contains':
-            passed = String(leftValue).includes(String(rightValue));
-            break;
-        case 'startsWith':
-            passed = String(leftValue).startsWith(String(rightValue));
-            break;
-        case 'endsWith':
-            passed = String(leftValue).endsWith(String(rightValue));
-            break;
-        case 'matches':
-            try {
-                // Remove regex delimiters if present
-                let pattern = String(rightValue);
-                if (pattern.startsWith('/') && pattern.lastIndexOf('/') > 0) {
-                    const lastSlash = pattern.lastIndexOf('/');
-                    const flags = pattern.substring(lastSlash + 1);
-                    pattern = pattern.substring(1, lastSlash);
-                    passed = new RegExp(pattern, flags).test(String(leftValue));
-                }
-                else {
-                    passed = new RegExp(pattern).test(String(leftValue));
-                }
-            }
-            catch (e) {
-                return {
-                    passed: false,
-                    expression: formatExpression(assertion),
-                    message: assertion.message,
-                    operator: assertion.operator,
-                    leftValue,
-                    rightValue,
-                    leftExpression: assertion.leftExpr,
-                    rightExpression: assertion.rightExpr,
-                    error: `Invalid regex pattern: ${rightValue}`,
-                    ...buildFailureContext()
-                };
-            }
-            break;
-        // Note: isType is handled earlier before resolveValue is called
-    }
-    return {
-        passed,
-        expression: formatExpression(assertion),
-        message: assertion.message,
-        operator: assertion.operator,
-        leftValue,
-        rightValue,
-        leftExpression: assertion.leftExpr,
-        rightExpression: assertion.rightExpr,
-        ...(!passed ? buildFailureContext() : {})
-    };
-}
-/**
- * Format the assertion expression for display
- */
-function formatExpression(assertion) {
-    if (assertion.rightExpr) {
-        return `${assertion.leftExpr} ${assertion.operator} ${assertion.rightExpr}`;
-    }
-    return `${assertion.leftExpr} ${assertion.operator}`;
-}
-//# sourceMappingURL=assertionRunner.js.map