@aifabrix/builder 2.43.0 → 2.44.1

package/lib/utils/external-system-display.js

@@ -10,118 +10,30 @@
 
 const chalk = require('chalk');
 const logger = require('./logger');
+const { SEP, statusGlyph } = require('./datasource-test-run-display');
+const { logEnvelopeForInteractiveCli } = require('./datasource-test-run-tty-log');
+const { displayLocalExternalTestPlanLayout } = require('./external-system-local-test-tty');
+const {
+  sectionTitle,
+  headerKeyValue,
+  formatStatusKeyValue,
+  formatDatasourceListRow,
+  integrationFooterLine,
+  formatSuccessParagraph,
+  formatBlockingError,
+  successGlyph,
+  failureGlyph
+} = require('./cli-test-layout-chalk');
+const { displaySystemAggregateDatasourceTestRuns } = require('./external-system-system-test-tty');
 
 /**
- * Displays system file results
- * @function displaySystemResults
- * @param {Object[]} systemResults - System file results
- */
-function displaySystemResults(systemResults) {
-  if (systemResults.length === 0) {
-    return;
-  }
-  logger.log(chalk.blue('System Files:'));
-  for (const systemResult of systemResults) {
-    if (systemResult.valid) {
-      logger.log(chalk.green(`  ✓ ${systemResult.file}`));
-    } else {
-      logger.log(chalk.red(`  ✗ ${systemResult.file}`));
-    }
-  }
-}
-
-/**
- * Displays verbose datasource details
- * @function displayVerboseDatasourceDetails
- * @param {Object} dsResult - Datasource result
- */
-function displayVerboseDatasourceDetails(dsResult) {
-  if (dsResult.warnings.length > 0) {
-    dsResult.warnings.forEach(warn => logger.log(chalk.yellow(`    ⚠ ${warn}`)));
-  }
-
-  if (dsResult.fieldMappingResults) {
-    const fm = dsResult.fieldMappingResults;
-    logger.log(chalk.gray(`    Field mappings: ${Object.keys(fm.mappedFields || {}).length} fields`));
-  }
-
-  if (dsResult.metadataSchemaResults) {
-    const ms = dsResult.metadataSchemaResults;
-    const statusMsg = ms.valid ? '    Metadata schema: ✓ Valid' : '    Metadata schema: ✗ Invalid';
-    logger.log(ms.valid ? chalk.gray(statusMsg) : chalk.red(statusMsg));
-  }
-}
-
-/**
- * Displays datasource file results
- * @function displayDatasourceResults
- * @param {Object[]} datasourceResults - Datasource file results
- * @param {boolean} verbose - Show detailed output
- */
-function displayDatasourceResults(datasourceResults, verbose) {
-  if (datasourceResults.length === 0) {
-    return;
-  }
-  logger.log(chalk.blue('\nDatasource Files:'));
-  for (const dsResult of datasourceResults) {
-    if (dsResult.valid) {
-      logger.log(chalk.green(`  ✓ ${dsResult.key} (${dsResult.file})`));
-    } else {
-      logger.log(chalk.red(`  ✗ ${dsResult.key} (${dsResult.file})`));
-      if (verbose && dsResult.errors.length > 0) {
-        dsResult.errors.forEach(err => logger.log(chalk.red(`    - ${err}`)));
-      }
-    }
-
-    if (verbose) {
-      displayVerboseDatasourceDetails(dsResult);
-    }
-  }
-}
-
-/**
- * Displays errors and warnings
- * @function displayErrorsAndWarnings
- * @param {string[]} errors - Error messages
- * @param {string[]} warnings - Warning messages
- */
-function displayErrorsAndWarnings(errors, warnings) {
-  if (errors.length > 0) {
-    logger.log(chalk.red('\n❌ Errors:'));
-    errors.forEach(err => logger.log(chalk.red(`  - ${err}`)));
-  }
-
-  if (warnings.length > 0) {
-    logger.log(chalk.yellow('\n⚠ Warnings:'));
-    warnings.forEach(warn => logger.log(chalk.yellow(`  - ${warn}`)));
-  }
-}
-
-/**
- * Displays final test status
- * @function displayFinalTestStatus
- * @param {boolean} valid - Whether all tests passed
- */
-function displayFinalTestStatus(valid) {
-  if (valid) {
-    logger.log(chalk.green('\n✅ All tests passed!'));
-  } else {
-    logger.log(chalk.red('\n❌ Some tests failed'));
-  }
-}
-
-/**
- * Displays formatted test results
+ * Displays formatted test results (local external `aifabrix test` — structured report layout).
  * @param {Object} results - Test results
  * @param {boolean} verbose - Show detailed output
+ * @param {string} [appName] - Integration folder / app key for header
  */
-function displayTestResults(results, verbose = false) {
-  logger.log(chalk.blue('\n📊 Test Results\n'));
-
-  displaySystemResults(results.systemResults);
-  displayDatasourceResults(results.datasourceResults, verbose);
-  displayErrorsAndWarnings(results.errors, results.warnings);
-  displayFinalTestStatus(results.valid);
+function displayTestResults(results, verbose = false, appName = '') {
+  displayLocalExternalTestPlanLayout(results, verbose, appName || results.appName || results.systemKey || 'unknown');
 }
 
 /**
@@ -131,9 +43,9 @@ function displayTestResults(results, verbose = false) {
  */
 function displayVerboseValidationResults(vr) {
   if (vr.isValid) {
-    logger.log(chalk.gray('    Validation: ✓ Valid'));
+    logger.log(chalk.gray('    Validation: ✔ Valid'));
   } else {
-    logger.log(chalk.red('    Validation: ✗ Invalid'));
+    logger.log(chalk.red('    Validation: ✖ Invalid'));
   }
   if (vr.errors && vr.errors.length > 0) {
     vr.errors.forEach(err => logger.log(chalk.red(`      - ${err}`)));
@@ -163,7 +75,7 @@ function displayVerboseFieldMappingResults(fmr) {
  */
 function displayVerboseEndpointResults(etr) {
   if (etr.endpointConfigured) {
-    logger.log(chalk.gray('    Endpoint: ✓ Configured'));
+    logger.log(chalk.gray('    Endpoint: ✔ Configured'));
   } else {
     logger.log(chalk.gray('    Endpoint: Not configured'));
   }
@@ -191,54 +103,244 @@ function displayVerboseIntegrationDetails(dsResult) {
 }
 
 /**
- * Displays a single datasource integration test result
- * @function displayDatasourceIntegrationResult
+ * @param {Object} dsResult
+ * @returns {'ok'|'warn'|'fail'|'skipped'}
+ */
+function legacyIntegrationRowStatus(dsResult) {
+  if (dsResult.skipped) return 'skipped';
+  if (!dsResult.success) return 'fail';
+  const w = dsResult.validationResults && dsResult.validationResults.warnings;
+  if (Array.isArray(w) && w.length > 0) return 'warn';
+  return 'ok';
+}
+
+function legacyIntegrationRowHint(dsResult) {
+  if (dsResult.skipped) return dsResult.reason || 'Skipped';
+  if (!dsResult.success) return 'Failed';
+  return legacyIntegrationRowStatus(dsResult) === 'warn' ? 'Partial' : 'Ready';
+}
+
+/**
+ * Displays a single datasource integration test result (legacy pipeline row).
  * @param {Object} dsResult - Datasource result
  * @param {boolean} verbose - Show detailed output
  */
 function displayDatasourceIntegrationResult(dsResult, verbose) {
+  const rowSt = legacyIntegrationRowStatus(dsResult);
+  const hint = legacyIntegrationRowHint(dsResult);
+  logger.log(formatDatasourceListRow(rowSt, dsResult.key, hint));
+
+  if (!dsResult.skipped && !dsResult.success && dsResult.error) {
+    logger.log(chalk.red(`    Error: ${dsResult.error}`));
+  }
+
+  if (verbose) {
+    displayVerboseIntegrationDetails(dsResult);
+  }
+}
+
+/**
+ * Worst status across server runs (envelope.status or transport failure).
+ * @param {Object} results
+ * @returns {'ok'|'warn'|'fail'}
+ */
+function serverRowFails(r) {
+  if (r.skipped) return false;
+  if (r.datasourceTestRun && r.datasourceTestRun.status === 'fail') return true;
+  return !r.datasourceTestRun && r.success === false;
+}
+
+function serverRowWarns(r) {
+  if (r.skipped) return false;
+  return !!(r.datasourceTestRun && r.datasourceTestRun.status === 'warn');
+}
+
+function deriveAggregateServerStatus(results) {
+  const ds = results.datasourceResults || [];
+  if (ds.length === 0) {
+    return results.success === false ? 'fail' : 'ok';
+  }
+  if (ds.some(serverRowFails)) return 'fail';
+  if (ds.some(serverRowWarns)) return 'warn';
+  return results.success === false ? 'fail' : 'ok';
+}
+
+/**
+ * Aggregate status for legacy pipeline integration results (no DatasourceTestRun envelope).
+ * @param {Object} results
+ * @returns {'ok'|'warn'|'fail'}
+ */
+function deriveAggregateLegacyIntegrationStatus(results) {
+  const ds = results.datasourceResults || [];
+  if (ds.length === 0) {
+    return results.success === false ? 'fail' : 'ok';
+  }
+  if (ds.some(r => !r.skipped && r.success === false)) return 'fail';
+  if (ds.some(r => legacyIntegrationRowStatus(r) === 'warn')) return 'warn';
+  return results.success === false ? 'fail' : 'ok';
+}
+
+function integrationResultsHaveEnvelope(results) {
+  return (results.datasourceResults || []).some(
+    r => r.datasourceTestRun && typeof r.datasourceTestRun === 'object'
+  );
+}
+
+/**
+ * One datasource with DatasourceTestRun — same display path as `aifabrix datasource test` (no server wrapper).
+ * @param {Object} results
+ * @returns {boolean}
+ */
+function isSingleUnskippedEnvelopeRun(results) {
+  const rows = results.datasourceResults || [];
+  if (rows.length !== 1) return false;
+  const r = rows[0];
+  return Boolean(
+    r && !r.skipped && r.datasourceTestRun && typeof r.datasourceTestRun === 'object'
+  );
+}
+
+function runLabelForServerRun(runType) {
+  return runType === 'e2e' ? 'test-e2e (dataplane)' : 'test-integration (dataplane)';
+}
+
+function renderOneServerDatasourceRow(dsResult, verbose, opts) {
+  logger.log('');
+  if (!dsResult.datasourceTestRun) {
+    logger.log(headerKeyValue('Datasource:', dsResult.key));
+  }
   if (dsResult.skipped) {
-    logger.log(chalk.yellow(`  ⚠ ${dsResult.key}: ${dsResult.reason}`));
+    logger.log(formatDatasourceListRow('skipped', dsResult.key, dsResult.reason || 'Skipped'));
     return;
   }
+  if (dsResult.datasourceTestRun) {
+    logEnvelopeForInteractiveCli(dsResult.datasourceTestRun, {
+      json: false,
+      summary: false,
+      debug: opts.debug,
+      requestedCapabilityKey: opts.requestedCapabilityKey
+    });
+    return;
+  }
+  displayDatasourceIntegrationResult(dsResult, verbose);
+}
 
-  if (dsResult.success) {
-    logger.log(chalk.green(`  ✓ ${dsResult.key}`));
-  } else {
-    logger.log(chalk.red(`  ✗ ${dsResult.key}`));
-    if (dsResult.error) {
-      logger.log(chalk.red(`    Error: ${dsResult.error}`));
-    }
+function logServerDatasourceTestRunHeader(results, runType, agg) {
+  logger.log('');
+  logger.log(sectionTitle('Server test results'));
+  logger.log('');
+  logger.log(headerKeyValue('System:', results.systemKey));
+  logger.log(headerKeyValue('Run:', runLabelForServerRun(runType)));
+  logger.log(formatStatusKeyValue(agg, statusGlyph(agg)));
+  logger.log('');
+  logger.log(chalk.gray(SEP));
+}
+
+function logServerDatasourceTestRunFooter(success, agg) {
+  logger.log(
+    integrationFooterLine(
+      success,
+      agg,
+      'All server tests passed.',
+      'Server tests completed with warnings.',
+      'Some server tests failed.'
+    )
+  );
+}
+
+/**
+ * Dataplane DatasourceTestRun layout (multi- or single-datasource).
+ * @param {Object} results
+ * @param {boolean} verbose
+ * @param {Object} opts
+ * @param {boolean|string} [opts.debug]
+ * @param {'integration'|'e2e'} [opts.runType]
+ */
+function displayServerDatasourceTestRunResults(results, verbose, opts = {}) {
+  const runType = opts.runType === 'e2e' ? 'e2e' : 'integration';
+
+  if (isSingleUnskippedEnvelopeRun(results)) {
+    const row = results.datasourceResults[0];
+    logEnvelopeForInteractiveCli(row.datasourceTestRun, {
+      json: false,
+      summary: false,
+      debug: opts.debug,
+      requestedCapabilityKey: opts.requestedCapabilityKey
+    });
+    return;
   }
 
-  if (verbose) {
-    displayVerboseIntegrationDetails(dsResult);
+  // Plan §17: system-level overview for multi-datasource results (no full §16 dump per datasource by default).
+  // Keep legacy per-datasource full envelope available only via datasource commands.
+  if (integrationResultsHaveEnvelope(results)) {
+    displaySystemAggregateDatasourceTestRuns(results, { runType, verbose: Boolean(verbose) });
+    return;
+  }
+
+  const agg = deriveAggregateServerStatus(results);
+  logServerDatasourceTestRunHeader(results, runType, agg);
+
+  if (results.datasourceResults.length === 0) {
+    logger.log('');
+    logger.log(chalk.yellow('No datasources tested'));
+    logger.log('');
+    return;
+  }
+
+  for (const dsResult of results.datasourceResults) {
+    renderOneServerDatasourceRow(dsResult, verbose, opts);
+    logger.log('');
+    logger.log(chalk.gray(SEP));
   }
+
+  logServerDatasourceTestRunFooter(results.success, agg);
 }
 
 /**
- * Displays formatted integration test results
+ * Displays formatted integration / E2E test results (legacy or DatasourceTestRun TTY).
  * @param {Object} results - Integration test results
  * @param {boolean} verbose - Show detailed output
+ * @param {Object} [displayOpts]
+ * @param {boolean|string} [displayOpts.debug] - Debug appendix for each envelope
+ * @param {'integration'|'e2e'} [displayOpts.runType]
+ * @param {string} [displayOpts.requestedCapabilityKey]
  */
-function displayIntegrationTestResults(results, verbose = false) {
-  logger.log(chalk.blue('\n📊 Integration Test Results\n'));
-  logger.log(chalk.blue(`System: ${results.systemKey}`));
+function displayIntegrationTestResults(results, verbose = false, displayOpts = {}) {
+  if (integrationResultsHaveEnvelope(results)) {
+    displayServerDatasourceTestRunResults(results, verbose, displayOpts);
+    return;
+  }
+
+  const agg = deriveAggregateLegacyIntegrationStatus(results);
+  logger.log('');
+  logger.log(sectionTitle('Integration test results'));
+  logger.log('');
+  logger.log(headerKeyValue('System:', results.systemKey));
+  logger.log(headerKeyValue('Run:', 'test-integration (pipeline)'));
+  logger.log(formatStatusKeyValue(agg, statusGlyph(agg)));
+  logger.log('');
+  logger.log(chalk.gray(SEP));
 
   if (results.datasourceResults.length === 0) {
+    logger.log('');
     logger.log(chalk.yellow('No datasources tested'));
     return;
   }
 
+  logger.log('');
   for (const dsResult of results.datasourceResults) {
     displayDatasourceIntegrationResult(dsResult, verbose);
   }
 
-  if (results.success) {
-    logger.log(chalk.green('\n✅ All integration tests passed!'));
-  } else {
-    logger.log(chalk.red('\n❌ Some integration tests failed'));
-  }
+  logger.log(
+    integrationFooterLine(
+      results.success,
+      agg,
+      'All integration tests passed.',
+      'Integration tests completed with warnings.',
+      'Some integration tests failed.'
+    )
+  );
 }
 
 /**
@@ -256,7 +358,9 @@ function displayIntegrationTestResults(results, verbose = false) {
  */
 /* eslint-disable max-statements,complexity -- Step iteration and status display */
 function displayE2EResults(data, verbose = false) {
-  logger.log(chalk.blue('\n📊 E2E Test Results\n'));
+  logger.log('');
+  logger.log(sectionTitle('E2E test results'));
+  logger.log('');
   if (data.status) {
     const statusLabel = data.status === 'running'
       ? chalk.yellow('running')
@@ -265,12 +369,12 @@ function displayE2EResults(data, verbose = false) {
         : data.status === 'failed'
           ? chalk.red('failed')
           : data.status;
-    logger.log(`Status: ${statusLabel}`);
+    logger.log(`${chalk.gray('Status:')} ${statusLabel}`);
   }
   const steps = data.steps || data.completedActions || [];
   if (steps.length === 0) {
     if (data.success === false) {
-      logger.log(chalk.red('✗ E2E test failed'));
+      logger.log(formatBlockingError('E2E test failed.'));
       if (data.error) logger.log(chalk.red(`  Error: ${data.error}`));
     } else if (data.status === 'running') {
       logger.log(chalk.gray('  No steps completed yet'));
@@ -286,7 +390,7 @@ function displayE2EResults(data, verbose = false) {
   for (const step of steps) {
     const name = step.name || step.step || 'unknown';
     const ok = step.success !== false && !step.error;
-    logger.log(`  ${ok ? chalk.green('✓') : chalk.red('✗')} ${name}`);
+    logger.log(`  ${ok ? successGlyph() : failureGlyph()} ${chalk.white(name)}`);
     if (!ok && (step.error || step.message)) logger.log(chalk.red(`    ${step.error || step.message}`));
     if (verbose && step.message && ok) logger.log(chalk.gray(`    ${step.message}`));
     if (verbose && ok && (name === 'sync' || step.step === 'sync') && step.evidence && step.evidence.jobs) {
@@ -308,7 +412,9 @@ function displayE2EResults(data, verbose = false) {
     return;
   }
   const allPassed = steps.every(s => s.success !== false && !s.error);
-  logger.log(allPassed ? chalk.green('\n✅ E2E test passed!') : chalk.red('\n❌ E2E test failed'));
+  logger.log(
+    allPassed ? formatSuccessParagraph('E2E test passed.') : `\n${formatBlockingError('E2E test failed.')}`
+  );
 }
 
 /**