@aifabrix/builder 2.22.2 → 2.31.1

package/lib/external-system-test.js

@@ -14,7 +14,8 @@ const fsSync = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const { testDatasourceViaPipeline } = require('./api/pipeline.api');
+const testHelpers = require('./utils/external-system-test-helpers');
+const { retryApiCall } = require('./utils/external-system-test-helpers');
 const { getDeploymentAuth } = require('./utils/token-manager');
 const { getDataplaneUrl } = require('./datasource-deploy');
 const { getConfig } = require('./config');
@@ -115,6 +116,144 @@ async function loadExternalSystemFiles(appName) {
   };
 }
 
+/**
+ * Validate system files against schema
+ * @param {Array} systemFiles - Array of system file objects
+ * @param {Object} externalSystemSchema - External system schema
+ * @returns {Object} Validation results
+ */
+function validateSystemFiles(systemFiles, externalSystemSchema) {
+  const systemResults = [];
+  let valid = true;
+  const errors = [];
+
+  for (const systemFile of systemFiles) {
+    const validation = validateAgainstSchema(systemFile.data, externalSystemSchema);
+    if (!validation.valid) {
+      valid = false;
+      errors.push(`System file ${path.basename(systemFile.path)}: ${validation.errors.join(', ')}`);
+    } else {
+      systemResults.push({
+        file: path.basename(systemFile.path),
+        valid: true
+      });
+    }
+  }
+
+  return { valid, errors, systemResults };
+}
+
+/**
+ * Validate datasource against schema and relationships
+ * @param {Object} datasource - Datasource configuration
+ * @param {string} systemKey - System key
+ * @param {Object} externalDataSourceSchema - External datasource schema
+ * @returns {Object} Validation result
+ */
+function validateDatasourceSchema(datasource, systemKey, externalDataSourceSchema) {
+  const errors = [];
+  const schemaValidation = validateAgainstSchema(datasource, externalDataSourceSchema);
+  if (!schemaValidation.valid) {
+    errors.push(...schemaValidation.errors);
+  }
+
+  if (systemKey && datasource.systemKey !== systemKey) {
+    errors.push(`systemKey mismatch: expected '${systemKey}', got '${datasource.systemKey}'`);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Test datasource with payload template
+ * @param {Object} datasource - Datasource configuration
+ * @param {boolean} verbose - Show detailed output
+ * @returns {Object} Test results
+ */
+function testDatasourceWithPayload(datasource, verbose) {
+  const errors = [];
+  const warnings = [];
+
+  // Validate field mappings
+  const fieldMappingResults = validateFieldMappings(datasource, datasource.testPayload);
+  if (!fieldMappingResults.valid) {
+    errors.push(...fieldMappingResults.errors);
+  }
+  if (fieldMappingResults.warnings.length > 0) {
+    warnings.push(...fieldMappingResults.warnings);
+  }
+
+  // Validate metadata schema
+  const metadataSchemaResults = validateMetadataSchema(datasource, datasource.testPayload);
+  if (!metadataSchemaResults.valid) {
+    errors.push(...metadataSchemaResults.errors);
+  }
+  if (metadataSchemaResults.warnings.length > 0) {
+    warnings.push(...metadataSchemaResults.warnings);
+  }
+
+  // Compare with expectedResult if provided
+  if (datasource.testPayload.expectedResult && fieldMappingResults.mappedFields && verbose) {
+    warnings.push('expectedResult validation not yet implemented (requires transformation engine)');
+  }
+
+  return {
+    fieldMappingResults,
+    metadataSchemaResults,
+    errors,
+    warnings,
+    valid: errors.length === 0
+  };
+}
+
+/**
+ * Validate a single datasource
+ * @param {Object} datasourceFile - Datasource file object
+ * @param {string} systemKey - System key
+ * @param {Object} externalDataSourceSchema - External datasource schema
+ * @param {boolean} verbose - Show detailed output
+ * @returns {Object} Datasource validation result
+ */
+function validateSingleDatasource(datasourceFile, systemKey, externalDataSourceSchema, verbose) {
+  const datasource = datasourceFile.data;
+  const datasourceResult = {
+    key: datasource.key,
+    file: path.basename(datasourceFile.path),
+    valid: true,
+    errors: [],
+    warnings: [],
+    fieldMappingResults: null,
+    metadataSchemaResults: null
+  };
+
+  // Validate against schema
+  const schemaValidation = validateDatasourceSchema(datasource, systemKey, externalDataSourceSchema);
+  if (!schemaValidation.valid) {
+    datasourceResult.valid = false;
+    datasourceResult.errors.push(...schemaValidation.errors);
+  }
+
+  // Test with testPayload if available
+  if (datasource.testPayload && datasource.testPayload.payloadTemplate) {
+    logger.log(chalk.blue(`  Testing datasource: ${datasource.key}`));
+    const payloadTestResults = testDatasourceWithPayload(datasource, verbose);
+    datasourceResult.fieldMappingResults = payloadTestResults.fieldMappingResults;
+    datasourceResult.metadataSchemaResults = payloadTestResults.metadataSchemaResults;
+    if (!payloadTestResults.valid) {
+      datasourceResult.valid = false;
+      datasourceResult.errors.push(...payloadTestResults.errors);
+    }
+    datasourceResult.warnings.push(...payloadTestResults.warnings);
+  } else {
+    datasourceResult.warnings.push('No testPayload.payloadTemplate found - skipping field mapping and metadata schema tests');
+  }
+
+  return datasourceResult;
+}
+
 /**
  * Runs unit tests for external system (local validation, no API calls)
  * @async
@@ -147,95 +286,28 @@ async function testExternalSystem(appName, options = {}) {
 
     // Validate system files
     logger.log(chalk.blue('📋 Validating system files...'));
-    for (const systemFile of systemFiles) {
-      const validation = validateAgainstSchema(systemFile.data, externalSystemSchema);
-      if (!validation.valid) {
-        results.valid = false;
-        results.errors.push(`System file ${path.basename(systemFile.path)}: ${validation.errors.join(', ')}`);
-      } else {
-        results.systemResults.push({
-          file: path.basename(systemFile.path),
-          valid: true
-        });
-      }
-    }
+    const systemValidation = validateSystemFiles(systemFiles, externalSystemSchema);
+    results.valid = systemValidation.valid;
+    results.errors.push(...systemValidation.errors);
+    results.systemResults = systemValidation.systemResults;
 
     // Validate datasource files
     logger.log(chalk.blue('📋 Validating datasource files...'));
-    const datasourcesToTest = options.datasource
-      ? datasourceFiles.filter(ds => ds.data.key === options.datasource || path.basename(ds.path).includes(options.datasource))
-      : datasourceFiles;
+    const datasourcesToTest = determineDatasourcesToTest(datasourceFiles, options.datasource);
+    const systemKey = systemFiles.length > 0 ? systemFiles[0].data.key : null;
 
     for (const datasourceFile of datasourcesToTest) {
-      const datasource = datasourceFile.data;
-      const datasourceResult = {
-        key: datasource.key,
-        file: path.basename(datasourceFile.path),
-        valid: true,
-        errors: [],
-        warnings: [],
-        fieldMappingResults: null,
-        metadataSchemaResults: null
-      };
-
-      // Validate against schema
-      const schemaValidation = validateAgainstSchema(datasource, externalDataSourceSchema);
-      if (!schemaValidation.valid) {
-        datasourceResult.valid = false;
-        datasourceResult.errors.push(...schemaValidation.errors);
+      const datasourceResult = validateSingleDatasource(
+        datasourceFile,
+        systemKey,
+        externalDataSourceSchema,
+        options.verbose
+      );
+
+      if (!datasourceResult.valid) {
         results.valid = false;
       }
 
-      // Validate relationships
-      if (systemFiles.length > 0) {
-        const systemKey = systemFiles[0].data.key;
-        if (datasource.systemKey !== systemKey) {
-          datasourceResult.valid = false;
-          datasourceResult.errors.push(`systemKey mismatch: expected '${systemKey}', got '${datasource.systemKey}'`);
-          results.valid = false;
-        }
-      }
-
-      // Test with testPayload if available
-      if (datasource.testPayload && datasource.testPayload.payloadTemplate) {
-        logger.log(chalk.blue(`  Testing datasource: ${datasource.key}`));
-
-        // Validate field mappings
-        const fieldMappingResults = validateFieldMappings(datasource, datasource.testPayload);
-        datasourceResult.fieldMappingResults = fieldMappingResults;
-        if (!fieldMappingResults.valid) {
-          datasourceResult.valid = false;
-          datasourceResult.errors.push(...fieldMappingResults.errors);
-          results.valid = false;
-        }
-        if (fieldMappingResults.warnings.length > 0) {
-          datasourceResult.warnings.push(...fieldMappingResults.warnings);
-        }
-
-        // Validate metadata schema
-        const metadataSchemaResults = validateMetadataSchema(datasource, datasource.testPayload);
-        datasourceResult.metadataSchemaResults = metadataSchemaResults;
-        if (!metadataSchemaResults.valid) {
-          datasourceResult.valid = false;
-          datasourceResult.errors.push(...metadataSchemaResults.errors);
-          results.valid = false;
-        }
-        if (metadataSchemaResults.warnings.length > 0) {
-          datasourceResult.warnings.push(...metadataSchemaResults.warnings);
-        }
-
-        // Compare with expectedResult if provided
-        if (datasource.testPayload.expectedResult && fieldMappingResults.mappedFields) {
-          // This would require actual transformation execution, which is complex
-          // For now, we just note that expectedResult is present
-          if (options.verbose) {
-            datasourceResult.warnings.push('expectedResult validation not yet implemented (requires transformation engine)');
-          }
-        }
-      } else {
-        datasourceResult.warnings.push('No testPayload.payloadTemplate found - skipping field mapping and metadata schema tests');
-      }
-
       results.datasourceResults.push(datasourceResult);
     }
 
@@ -253,50 +325,49 @@ async function testExternalSystem(appName, options = {}) {
  * @param {number} backoffMs - Initial backoff in milliseconds
  * @returns {Promise<*>} Function result
  */
-async function retryApiCall(fn, maxRetries = 3, backoffMs = 1000) {
-  let lastError;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt < maxRetries) {
-        const delay = backoffMs * Math.pow(2, attempt);
-        await new Promise(resolve => setTimeout(resolve, delay));
-      }
-    }
+
+/**
+ * Setup authentication and get dataplane URL for integration tests
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Test options
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} Object with authConfig and dataplaneUrl
+ * @throws {Error} If authentication fails
+ */
+async function setupIntegrationTestAuth(appName, options, config) {
+  const environment = options.environment || 'dev';
+  const controllerUrl = options.controller || config.deployment?.controllerUrl || 'http://localhost:3000';
+  const authConfig = await getDeploymentAuth(controllerUrl, environment, appName);
+
+  if (!authConfig.token && !authConfig.clientId) {
+    throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
   }
-  throw lastError;
+
+  logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
+  const dataplaneUrl = await getDataplaneUrl(controllerUrl, appName, environment, authConfig);
+  logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+
+  return { authConfig, dataplaneUrl };
 }
 
 /**
- * Calls pipeline test endpoint using centralized API client
- * @async
- * @param {string} systemKey - System key
- * @param {string} datasourceKey - Datasource key
- * @param {Object} payloadTemplate - Test payload template
- * @param {string} dataplaneUrl - Dataplane URL
- * @param {Object} authConfig - Authentication configuration
- * @param {number} timeout - Request timeout in milliseconds
- * @returns {Promise<Object>} Test response
+ * Determine which datasources to test
+ * @param {Array} datasourceFiles - All datasource files
+ * @param {string} [datasourceFilter] - Optional datasource filter
+ * @returns {Array} Filtered datasource files
+ * @throws {Error} If no datasources found
  */
-async function callPipelineTestEndpoint(systemKey, datasourceKey, payloadTemplate, dataplaneUrl, authConfig, timeout = 30000) {
-  const response = await retryApiCall(async() => {
-    return await testDatasourceViaPipeline(
-      dataplaneUrl,
-      systemKey,
-      datasourceKey,
-      authConfig,
-      { payloadTemplate },
-      { timeout }
-    );
-  });
-
-  if (!response.success || !response.data) {
-    throw new Error(`Test endpoint failed: ${response.error || response.formattedError || 'Unknown error'}`);
+function determineDatasourcesToTest(datasourceFiles, datasourceFilter) {
+  const datasourcesToTest = datasourceFilter
+    ? datasourceFiles.filter(ds => ds.data.key === datasourceFilter || path.basename(ds.path).includes(datasourceFilter))
+    : datasourceFiles;
+
+  if (datasourcesToTest.length === 0) {
+    throw new Error('No datasources found to test');
   }
 
-  return response.data.data || response.data;
+  return datasourcesToTest;
 }
 
 /**
@@ -331,29 +402,12 @@ async function testExternalSystemIntegration(appName, options = {}) {
 
     const systemKey = systemFiles[0].data.key;
 
-    // Get authentication
+    // Setup authentication and dataplane URL
     const config = await getConfig();
-    const environment = options.environment || 'dev';
-    const controllerUrl = options.controller || config.deployment?.controllerUrl || 'http://localhost:3000';
-    const authConfig = await getDeploymentAuth(controllerUrl, environment, appName);
-
-    if (!authConfig.token && !authConfig.clientId) {
-      throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
-    }
-
-    // Get dataplane URL
-    logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
-    const dataplaneUrl = await getDataplaneUrl(controllerUrl, appName, environment, authConfig);
-    logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+    const { authConfig, dataplaneUrl } = await setupIntegrationTestAuth(appName, options, config);
 
     // Determine datasources to test
-    const datasourcesToTest = options.datasource
-      ? datasourceFiles.filter(ds => ds.data.key === options.datasource || path.basename(ds.path).includes(options.datasource))
-      : datasourceFiles;
-
-    if (datasourcesToTest.length === 0) {
-      throw new Error('No datasources found to test');
-    }
+    const datasourcesToTest = determineDatasourcesToTest(datasourceFiles, options.datasource);
 
     const results = {
       success: true,
@@ -362,12 +416,7 @@ async function testExternalSystemIntegration(appName, options = {}) {
     };
 
     // Load custom payload if provided
-    let customPayload = null;
-    if (options.payload) {
-      const payloadPath = path.isAbsolute(options.payload) ? options.payload : path.join(process.cwd(), options.payload);
-      const payloadContent = await fs.readFile(payloadPath, 'utf8');
-      customPayload = JSON.parse(payloadContent);
-    }
+    const customPayload = await testHelpers.loadCustomPayload(options.payload);
 
     // Test each datasource
     for (const datasourceFile of datasourcesToTest) {
@@ -377,12 +426,8 @@ async function testExternalSystemIntegration(appName, options = {}) {
       logger.log(chalk.blue(`\n📡 Testing datasource: ${datasourceKey}`));
 
       // Determine payload to use
-      let payloadTemplate;
-      if (customPayload) {
-        payloadTemplate = customPayload;
-      } else if (datasource.testPayload && datasource.testPayload.payloadTemplate) {
-        payloadTemplate = datasource.testPayload.payloadTemplate;
-      } else {
+      const payloadTemplate = testHelpers.determinePayloadTemplate(datasource, datasourceKey, customPayload);
+      if (!payloadTemplate) {
         logger.log(chalk.yellow(`  ⚠ No test payload found for ${datasourceKey}, skipping...`));
         results.datasourceResults.push({
           key: datasourceKey,
@@ -393,23 +438,14 @@ async function testExternalSystemIntegration(appName, options = {}) {
       }
 
       try {
-        const testResponse = await callPipelineTestEndpoint(
+        const datasourceResult = await testHelpers.testSingleDatasource({
           systemKey,
           datasourceKey,
           payloadTemplate,
           dataplaneUrl,
           authConfig,
-          parseInt(options.timeout, 10) || 30000
-        );
-
-        const datasourceResult = {
-          key: datasourceKey,
-          skipped: false,
-          success: testResponse.success !== false,
-          validationResults: testResponse.validationResults || {},
-          fieldMappingResults: testResponse.fieldMappingResults || {},
-          endpointTestResults: testResponse.endpointTestResults || {}
-        };
+          timeout: parseInt(options.timeout, 10) || 30000
+        });
 
         if (!datasourceResult.success) {
           results.success = false;
@@ -438,6 +474,5 @@ module.exports = {
   testExternalSystemIntegration,
   displayTestResults,
   displayIntegrationTestResults,
-  callPipelineTestEndpoint,
   retryApiCall
 };