@aifabrix/builder 2.43.0 → 2.44.1

package/lib/datasource/test-e2e.js

@@ -1,10 +1,9 @@
 /**
- * Datasource E2E test - run full E2E test via dataplane external API
- * @fileoverview Datasource E2E test logic (config, credential, sync, data, CIP)
+ * Datasource E2E test — unified POST /api/v1/validation/run (runType=e2e).
+ * @fileoverview Datasource E2E via DatasourceTestRun envelope
  * @author AI Fabrix Team
  * @version 2.0.0
  */
-/* eslint-disable max-statements -- Auth setup, API call, polling, debug log */
 
 const path = require('path');
 const fs = require('fs').promises;
@@ -12,19 +11,51 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { getIntegrationPath } = require('../utils/paths');
 const { resolveAppKeyForDatasource } = require('./resolve-app');
-const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
-const { resolveControllerUrl } = require('../utils/controller-url');
-const { getDeviceOnlyAuth } = require('../utils/token-manager');
-const { testDatasourceE2E, getE2ETestRun } = require('../api/external-test.api');
+const { infoLine } = require('../utils/cli-test-layout-chalk');
+const { runUnifiedDatasourceValidation } = require('./unified-validation-run');
+const { includeDebugForRequest } = require('../utils/validation-run-request');
+const { e2eShapeFromEnvelope } = require('../utils/datasource-test-run-legacy-adapter');
 const { writeTestLog } = require('../utils/test-log-writer');
 
-const DEFAULT_POLL_INTERVAL_MS = 2500;
 const DEFAULT_POLL_TIMEOUT_MS = 15 * 60 * 1000;
 
+/**
+ * @param {Object} options
+ * @param {string|number} timeoutMs
+ * @param {string|Object|null} pk
+ */
+function buildUnifiedE2eRunOptions(options, timeoutMs, pk) {
+  return {
+    app: options.app,
+    environment: options.environment,
+    runType: 'e2e',
+    debug: options.debug,
+    verbose: options.verbose,
+    async: options.async !== false,
+    noAsync: options.async === false,
+    testCrud: options.testCrud,
+    recordId: options.recordId,
+    cleanup: options.cleanup,
+    primaryKeyValue: pk,
+    minVectorHits: options.minVectorHits,
+    minProcessed: options.minProcessed,
+    minRecordCount: options.minRecordCount,
+    capabilityKey: options.capabilityKey,
+    timeout: timeoutMs,
+    sync: options.sync === true
+  };
+}
+
+function logE2eDatasourceBanner(datasourceKey, verbose) {
+  if (!verbose) return;
+  logger.log('');
+  logger.log(infoLine(`🧪 Running E2E test for datasource: ${datasourceKey}`));
+}
+
 /**
  * Resolve primaryKeyValue for request body: string as-is, or read and parse JSON from @path
- * @param {string} [value] - Literal value or path prefixed with @ (e.g. @pk.json)
- * @returns {Promise<string|Object|null>} Resolved value for body.primaryKeyValue, or null if absent
+ * @param {string} [value]
+ * @returns {Promise<string|Object|null>}
  */
 async function resolvePrimaryKeyValue(value) {
   if (value === null || value === undefined || value === '') return null;
@@ -37,174 +68,110 @@ async function resolvePrimaryKeyValue(value) {
   return str;
 }
 
-/**
- * Build E2E request body from options
- * @param {Object} options - Command options
- * @returns {Promise<Object>} Request body
- */
-async function buildE2EBody(options) {
-  const body = {};
-  if (options.debug) body.includeDebug = true;
-  if (options.verbose) body.audit = true;
-  if (options.testCrud === true) body.testCrud = true;
-  if (options.recordId !== undefined && options.recordId !== null && options.recordId !== '') body.recordId = String(options.recordId);
-  if (options.cleanup === false) body.cleanup = false;
-  else if (options.cleanup === true) body.cleanup = true;
-  const pk = await resolvePrimaryKeyValue(options.primaryKeyValue);
-  if (pk !== null && pk !== undefined) body.primaryKeyValue = pk;
-  return body;
+function e2eIntegrationLogDir(appKey) {
+  return path.dirname(getIntegrationPath(appKey));
 }
 
 /**
- * Poll E2E test run until completed or failed
- * @param {string} dataplaneUrl - Dataplane URL
- * @param {string} sourceIdOrKey - Source ID or key
- * @param {string} testRunId - Test run ID
- * @param {Object} authConfig - Auth config
- * @param {Object} opts - Poll options
- * @param {number} [opts.intervalMs] - Poll interval (ms)
- * @param {number} [opts.timeoutMs] - Max wait (ms)
- * @param {boolean} [opts.verbose] - Log each poll
- * @returns {Promise<Object>} Final poll result (status completed or failed)
+ * Throw when unified run failed, timed out, or needs async; optionally write debug log.
+ * @returns {Promise<void>}
  */
-async function pollE2ETestRun(dataplaneUrl, sourceIdOrKey, testRunId, authConfig, opts = {}) {
-  const intervalMs = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
-  const verbose = opts.verbose === true;
-  const deadline = Date.now() + timeoutMs;
-  let last;
-  while (Date.now() < deadline) {
-    last = await getE2ETestRun(dataplaneUrl, sourceIdOrKey, testRunId, authConfig);
-    if (last.status === 'completed' || last.status === 'failed') {
-      return last;
+async function throwIfUnifiedE2EBlocked(unifiedResult, appKey, options, requestMeta) {
+  if (unifiedResult.apiError) {
+    const msg =
+      unifiedResult.apiError.formattedError ||
+      unifiedResult.apiError.error ||
+      'E2E request failed';
+    if (options.debug) {
+      await writeTestLog(
+        appKey,
+        { request: requestMeta, error: msg },
+        'test-e2e',
+        e2eIntegrationLogDir(appKey)
+      );
     }
-    if (verbose) {
-      const steps = last.completedActions || [];
-      logger.log(chalk.gray(`  Polling… status: ${last.status}, ${steps.length} step(s) completed`));
+    throw new Error(msg);
+  }
+  if (unifiedResult.pollTimedOut) {
+    const err = new Error('Report incomplete: timeout');
+    if (options.debug) {
+      await writeTestLog(
+        appKey,
+        { request: requestMeta, error: err.message },
+        'test-e2e',
+        e2eIntegrationLogDir(appKey)
+      );
     }
-    await new Promise(r => setTimeout(r, intervalMs));
+    throw err;
+  }
+  if (unifiedResult.incompleteNoAsync) {
+    throw new Error(
+      'Report incomplete: async polling disabled (--no-async) but server returned partial report.'
+    );
   }
-  throw new Error(
-    `E2E test run did not complete within ${timeoutMs / 1000}s (run ID: ${testRunId})`
-  );
 }
 
 /**
- * Run E2E test for one datasource (Bearer token or API key required; no client credentials).
- * Default: async start + polling until completed/failed. Use options.async === false for sync.
- *
+ * Run E2E test for one datasource (unified validation API; deployment auth like test-integration).
  * @async
- * @param {string} datasourceKey - Datasource key (used as sourceIdOrKey)
- * @param {Object} options - Options
- * @param {string} [options.app] - App key (or resolve from cwd)
- * @param {string} [options.environment] - Environment (dev, tst, pro)
- * @param {boolean} [options.debug] - Include debug, write log file
- * @param {boolean} [options.verbose] - Verbose output (e.g. poll progress)
- * @param {boolean} [options.async] - If false, use sync mode (no polling). Default true.
- * @param {boolean} [options.testCrud] - Set body testCrud true
- * @param {string} [options.recordId] - Set body recordId
- * @param {boolean} [options.cleanup] - Set body cleanup (default true)
- * @param {string} [options.primaryKeyValue] - Set body primaryKeyValue (string or @path to JSON)
- * @param {number} [options.pollIntervalMs] - Poll interval in ms (default 2500)
- * @param {number} [options.pollTimeoutMs] - Poll timeout in ms (default 15 min)
- * @returns {Promise<Object>} E2E test result (steps, success, error, etc.)
+ * @param {string} datasourceKey
+ * @param {Object} options
+ * @param {boolean} [options.sync] - Publish local datasource JSON before validation when true
+ * @returns {Promise<Object>} Shape compatible with displayE2EResults (steps, success, status)
  */
 async function runDatasourceTestE2E(datasourceKey, options = {}) {
   if (!datasourceKey || typeof datasourceKey !== 'string') {
     throw new Error('Datasource key is required');
   }
   const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
-  const controllerUrl = await resolveControllerUrl();
-  const { resolveEnvironment } = require('../core/config');
-  const environment = options.environment || await resolveEnvironment();
-  const authConfig = await getDeviceOnlyAuth(controllerUrl);
-  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
 
-  logger.log(chalk.blue(`\n🧪 Running E2E test for datasource: ${datasourceKey}`));
+  logE2eDatasourceBanner(datasourceKey, options.verbose);
+
+  const pk = await resolvePrimaryKeyValue(options.primaryKeyValue);
+  const timeoutRaw =
+    options.timeout !== undefined && options.timeout !== null && options.timeout !== ''
+      ? parseInt(String(options.timeout), 10)
+      : options.pollTimeoutMs;
+  const timeoutMs =
+    Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? timeoutRaw : DEFAULT_POLL_TIMEOUT_MS;
 
-  const body = await buildE2EBody(options);
-  const useAsync = options.async !== false;
   const requestMeta = {
-    sourceIdOrKey: datasourceKey,
-    dataplaneUrl,
-    includeDebug: options.debug,
+    datasourceKey,
+    runType: 'e2e',
+    includeDebug: includeDebugForRequest(options.debug),
     testCrud: options.testCrud,
     recordId: options.recordId,
     cleanup: options.cleanup,
-    primaryKeyValue: options.primaryKeyValue !== undefined && options.primaryKeyValue !== null
+    primaryKeyValue: pk !== undefined && pk !== null,
+    minVectorHits: options.minVectorHits,
+    minProcessed: options.minProcessed,
+    minRecordCount: options.minRecordCount
   };
 
-  const execOpts = {
-    dataplaneUrl,
+  const unifiedResult = await runUnifiedDatasourceValidation(
     datasourceKey,
-    authConfig,
-    body,
-    useAsync,
-    verbose: options.verbose,
-    pollIntervalMs: options.pollIntervalMs,
-    pollTimeoutMs: options.pollTimeoutMs
-  };
-  let data;
-  try {
-    data = await executeE2EWithOptionalPoll(execOpts);
-  } catch (error) {
-    if (options.debug) {
-      const appPath = getIntegrationPath(appKey);
-      const integrationDir = path.dirname(appPath);
-      await writeTestLog(appKey, { request: requestMeta, error: error.message }, 'test-e2e', integrationDir);
-    }
-    throw error;
-  }
+    buildUnifiedE2eRunOptions(options, timeoutMs, pk)
+  );
 
-  if (options.debug) {
-    const appPath = getIntegrationPath(appKey);
-    const integrationDir = path.dirname(appPath);
-    const logPath = await writeTestLog(appKey, { request: requestMeta, response: data }, 'test-e2e', integrationDir);
-    logger.log(chalk.gray(`  Debug log: ${logPath}`));
-  }
+  await throwIfUnifiedE2EBlocked(unifiedResult, appKey, options, requestMeta);
 
-  return data;
-}
+  const display = e2eShapeFromEnvelope(unifiedResult.envelope);
+  Object.assign(display, { datasourceTestRun: unifiedResult.envelope });
 
-/**
- * Call E2E API and optionally poll until completed. On throw, caller should log if debug.
- * @param {Object} opts - Options
- * @param {string} opts.dataplaneUrl - Dataplane URL
- * @param {string} opts.datasourceKey - Source key
- * @param {Object} opts.authConfig - Auth config
- * @param {Object} opts.body - Request body
- * @param {boolean} opts.useAsync - Whether to use async + poll
- * @param {boolean} opts.verbose - Verbose poll progress
- * @param {number} [opts.pollIntervalMs] - Override poll interval (ms)
- * @param {number} [opts.pollTimeoutMs] - Override poll timeout (ms)
- * @returns {Promise<Object>} Final result data
- */
-/* eslint-disable-next-line max-params -- single opts object; destructuring in body */
-async function executeE2EWithOptionalPoll(opts) {
-  const { dataplaneUrl, datasourceKey, authConfig, body, useAsync, verbose, pollIntervalMs, pollTimeoutMs } = opts;
-  const response = await testDatasourceE2E(dataplaneUrl, datasourceKey, authConfig, body, {
-    asyncRun: useAsync
-  });
-  let data = response.data || response;
-  const runId = (data?.testRunId !== null && data?.testRunId !== undefined)
-    ? (typeof data.testRunId === 'string' ? data.testRunId : data.testRunId.id || data.testRunId.key)
-    : null;
-  if (useAsync && runId) {
-    data = await pollE2ETestRun(
-      dataplaneUrl,
-      datasourceKey,
-      runId,
-      authConfig,
-      {
-        intervalMs: pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
-        timeoutMs: pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS,
-        verbose
-      }
+  if (options.debug) {
+    const logPath = await writeTestLog(
+      appKey,
+      { request: requestMeta, response: unifiedResult.envelope },
+      'test-e2e',
+      e2eIntegrationLogDir(appKey)
     );
+    logger.log(chalk.gray(`  Debug log: ${logPath}`));
   }
-  return data;
+
+  return display;
 }
 
 module.exports = {
-  runDatasourceTestE2E
+  runDatasourceTestE2E,
+  resolvePrimaryKeyValue
 };

package/lib/datasource/test-integration.js

@@ -1,174 +1,166 @@
 /**
- * Datasource integration test - run config test for one datasource via pipeline
+ * Datasource integration test — unified dataplane validation (runType=integration).
  * @fileoverview Datasource integration test logic
  * @author AI Fabrix Team
  * @version 2.0.0
  */
-/* eslint-disable max-lines-per-function,max-statements,complexity -- Load config, resolve datasource, call pipeline test */
 
-const path = require('path');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { getIntegrationPath } = require('../utils/paths');
 const { resolveAppKeyForDatasource } = require('./resolve-app');
-const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
-const { loadConfigFile } = require('../utils/config-format');
-const { setupIntegrationTestAuth } = require('../external-system/test-auth');
-const { getConfig } = require('../core/config');
-const { testDatasourceViaPipeline } = require('../api/pipeline.api');
+const { infoLine } = require('../utils/cli-test-layout-chalk');
+const {
+  getSystemKeyFromAppKey,
+  findDatasourceFileByKey
+} = require('./integration-context');
+const { runUnifiedDatasourceValidation } = require('./unified-validation-run');
+const { integrationResultFromEnvelope } = require('../utils/datasource-test-run-legacy-adapter');
 const { writeTestLog } = require('../utils/test-log-writer');
-const testHelpers = require('../utils/external-system-test-helpers');
-const fs = require('fs').promises;
 
 /**
- * Get systemKey for an integration app (from application config and first system file)
- * @param {string} appKey - Integration app key
+ * @param {string} appKey - Integration folder name (same as --app; system key in publish flows)
  * @returns {Promise<string>} systemKey
  */
-async function getSystemKeyFromAppKey(appKey) {
-  const appPath = getIntegrationPath(appKey);
-  const configPath = resolveApplicationConfigPath(appPath);
-  const config = loadConfigFile(configPath);
-  if (!config.externalIntegration || !config.externalIntegration.systems || config.externalIntegration.systems.length === 0) {
-    throw new Error(`No externalIntegration.systems found in ${configPath}`);
-  }
-  const systemFile = config.externalIntegration.systems[0];
-  const systemPath = path.isAbsolute(systemFile)
-    ? systemFile
-    : path.join(appPath, systemFile);
-  const systemContent = await fs.readFile(systemPath, 'utf8');
-  const yaml = require('js-yaml');
-  const systemConfig = yaml.load(systemContent);
-  return systemConfig?.key || path.basename(systemFile, '-system.yaml').replace('-system', '');
+async function getSystemKeyFromAppKeyExport(appKey) {
+  return getSystemKeyFromAppKey(appKey);
+}
+
+function legacyFailureShell(datasourceKey, systemKey, error, datasourceTestRun, runMeta) {
+  return {
+    key: datasourceKey,
+    systemKey,
+    success: false,
+    skipped: false,
+    validationResults: {},
+    fieldMappingResults: {},
+    endpointTestResults: {},
+    error,
+    datasourceTestRun,
+    runMeta
+  };
 }
 
 /**
- * Find a datasource filename by matching the key inside the file (fallback when filename-base match fails).
- * @param {string} appPath - Integration app directory path
- * @param {string} schemaBasePath - Schema base path (relative or absolute)
- * @param {string[]} datasourceFiles - List of datasource filenames from application config
- * @param {string} datasourceKey - Datasource key to find
- * @returns {string|null} Filename if found, null otherwise
+ * @returns {{ body: Object, apiErrMsg?: string }|null}
  */
-function findDatasourceFileByKey(appPath, schemaBasePath, datasourceFiles, datasourceKey) {
-  const fsSync = require('fs');
-  for (const f of datasourceFiles) {
-    if (!f || typeof f !== 'string') continue;
-    const fullPath = path.isAbsolute(schemaBasePath)
-      ? path.join(schemaBasePath, f)
-      : path.join(appPath, schemaBasePath, f);
-    if (!fsSync.existsSync(fullPath)) continue;
-    try {
-      const parsed = loadConfigFile(fullPath);
-      if (parsed && parsed.key === datasourceKey) return f;
-    } catch {
-      // skip unreadable or invalid files
-    }
+function integrationEarlyExitBody(datasourceKey, systemKey, unifiedResult, runMeta) {
+  if (unifiedResult.apiError) {
+    const errMsg =
+      unifiedResult.apiError.formattedError ||
+      unifiedResult.apiError.error ||
+      'Request failed';
+    return {
+      body: legacyFailureShell(datasourceKey, systemKey, errMsg, null, runMeta),
+      apiErrMsg: errMsg
+    };
+  }
+  if (unifiedResult.pollTimedOut) {
+    return {
+      body: legacyFailureShell(
+        datasourceKey,
+        systemKey,
+        'Report incomplete: timeout',
+        unifiedResult.envelope,
+        runMeta
+      )
+    };
+  }
+  if (unifiedResult.incompleteNoAsync) {
+    return {
+      body: legacyFailureShell(
+        datasourceKey,
+        systemKey,
+        'Report incomplete (async required)',
+        unifiedResult.envelope,
+        runMeta
+      )
+    };
   }
   return null;
 }
 
 /**
- * Run integration test for one datasource
+ * Run integration test for one datasource (unified validation API).
  * @async
  * @param {string} datasourceKey - Datasource key
  * @param {Object} options - Options
  * @param {string} [options.app] - App key (or resolve from cwd)
  * @param {string} [options.payload] - Path to custom payload file
  * @param {string} [options.environment] - Environment (dev, tst, pro)
- * @param {boolean} [options.debug] - Include debug, write log file
- * @param {number} [options.timeout] - Request timeout ms
- * @returns {Promise<Object>} Test result
+ * @param {boolean} [options.verbose] - explain=true on request
+ * @param {boolean|string} [options.debug] - Truthy enables includeDebug and log file; string `summary`|`full`|`raw` selects TTY appendix (CLI)
+ * @param {number|string} [options.timeout] - Aggregate timeout ms
+ * @param {boolean} [options.sync] - Publish local datasource JSON before validation when true
+ * @returns {Promise<Object>} Legacy-shaped result + datasourceTestRun / runMeta when present
  */
+function logIntegrationDatasourceBanner(datasourceKey, systemKey, verbose) {
+  if (!verbose) return;
+  logger.log('');
+  logger.log(infoLine(`📡 Testing datasource: ${datasourceKey} (system: ${systemKey})`));
+}
+
 async function runDatasourceTestIntegration(datasourceKey, options = {}) {
   if (!datasourceKey || typeof datasourceKey !== 'string') {
     throw new Error('Datasource key is required');
   }
   const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
   const systemKey = await getSystemKeyFromAppKey(appKey);
-  const appPath = getIntegrationPath(appKey);
-  const config = loadConfigFile(resolveApplicationConfigPath(appPath));
-  const schemaBasePath = config.externalIntegration?.schemaBasePath || './';
-  const datasourceFiles = config.externalIntegration?.dataSources || [];
-  let datasourceFile = datasourceFiles.find(f => {
-    const base = path.basename(f, path.extname(f));
-    return base === datasourceKey || base.includes(datasourceKey);
-  });
-  if (!datasourceFile) {
-    datasourceFile = findDatasourceFileByKey(appPath, schemaBasePath, datasourceFiles, datasourceKey);
-  }
-  if (!datasourceFile) {
-    throw new Error(`Datasource '${datasourceKey}' not found in application config`);
-  }
-  const datasourcePath = path.isAbsolute(schemaBasePath)
-    ? path.join(schemaBasePath, datasourceFile)
-    : path.join(appPath, schemaBasePath, datasourceFile);
-  const datasource = loadConfigFile(datasourcePath);
-  if (datasource.key !== datasourceKey) {
-    throw new Error(`Datasource key mismatch: file has '${datasource.key}', expected '${datasourceKey}'`);
-  }
 
-  const configObj = await getConfig();
-  const { authConfig, dataplaneUrl } = await setupIntegrationTestAuth(appKey, options, configObj);
-  const customPayload = await testHelpers.loadCustomPayload(options.payload);
-  const payloadTemplate = testHelpers.determinePayloadTemplate(datasource, datasourceKey, customPayload);
-  if (!payloadTemplate) {
-    throw new Error(`No test payload found for datasource '${datasourceKey}'`);
-  }
+  logIntegrationDatasourceBanner(datasourceKey, systemKey, options.verbose);
 
-  logger.log(chalk.blue(`\n📡 Testing datasource: ${datasourceKey} (system: ${systemKey})`));
+  const unifiedResult = await runUnifiedDatasourceValidation(datasourceKey, {
+    app: options.app,
+    environment: options.environment,
+    runType: 'integration',
+    payload: options.payload,
+    debug: options.debug,
+    verbose: options.verbose,
+    timeout: options.timeout,
+    async: true,
+    noAsync: false,
+    sync: options.sync === true
+  });
 
-  const testData = { payloadTemplate };
-  if (options.debug) {
-    testData.includeDebug = true;
-  }
-  const timeout = parseInt(options.timeout, 10) || 30000;
+  const runMeta = {
+    apiError: unifiedResult.apiError,
+    pollTimedOut: unifiedResult.pollTimedOut,
+    incompleteNoAsync: unifiedResult.incompleteNoAsync
+  };
 
-  let response;
-  try {
-    response = await testDatasourceViaPipeline({
-      dataplaneUrl,
-      systemKey,
-      datasourceKey,
-      authConfig,
-      testData,
-      options: { timeout }
-    });
-  } catch (error) {
-    const result = { key: datasourceKey, success: false, error: error.message };
-    if (options.debug) {
-      await writeTestLog(appKey, { request: { systemKey, datasourceKey }, error: error.message }, 'test-integration');
+  const early = integrationEarlyExitBody(datasourceKey, systemKey, unifiedResult, runMeta);
+  if (early) {
+    if (early.apiErrMsg && options.debug) {
+      await writeTestLog(
+        appKey,
+        { request: { systemKey, datasourceKey }, error: early.apiErrMsg },
+        'test-integration'
+      );
     }
-    return result;
+    return early.body;
   }
 
-  const data = response.data || response;
-  const success = data.success !== false;
-  const result = {
-    key: datasourceKey,
-    systemKey,
-    success,
-    skipped: false,
-    validationResults: data.validationResults || {},
-    fieldMappingResults: data.fieldMappingResults || {},
-    endpointTestResults: data.endpointTestResults || {}
-  };
-  if (data.error) {
-    result.error = data.error;
-  }
+  const legacy = integrationResultFromEnvelope(unifiedResult.envelope, datasourceKey);
+  legacy.systemKey = systemKey;
+  legacy.datasourceTestRun = unifiedResult.envelope;
+  legacy.runMeta = { apiError: null, pollTimedOut: false, incompleteNoAsync: false };
 
-  if (options.debug) {
-    const logPath = await writeTestLog(appKey, {
-      request: { systemKey, datasourceKey, includeDebug: true },
-      response: data
-    }, 'test-integration');
+  if (options.debug && unifiedResult.envelope) {
+    const logPath = await writeTestLog(
+      appKey,
+      {
+        request: { systemKey, datasourceKey, includeDebug: true },
+        response: unifiedResult.envelope
+      },
+      'test-integration'
+    );
     logger.log(chalk.gray(`  Debug log: ${logPath}`));
   }
 
-  return result;
+  return legacy;
 }
 
 module.exports = {
   runDatasourceTestIntegration,
-  getSystemKeyFromAppKey
+  getSystemKeyFromAppKey: getSystemKeyFromAppKeyExport,
+  findDatasourceFileByKey
 };