@aifabrix/builder 2.52.1 → 2.53.1

package/integration/hubspot-test/test-dataplane-down-tests.js

@@ -1,386 +0,0 @@
-/**
- * Test Functions for Dataplane Down Tests
- *
- * Individual test functions for dataplane down test suite.
- *
- * @fileoverview Test functions for dataplane down tests
- * @author AI Fabrix Team
- * @version 2.0.0
- */
-'use strict';
-
-const path = require('path');
-const fs = require('fs').promises;
-const {
-  logInfo,
-  runCommand,
-  validateError,
-  isTimeoutResult,
-  validateDownloadDeleteResult,
-  validateDeleteResult,
-  validateWizardResult
-} = require('./test-dataplane-down-helpers');
-
-const INVALID_DATAPLANE_URL = 'http://localhost:9999';
-const CONTROLLER_URL = process.env.CONTROLLER_URL || 'http://localhost:3110';
-const ENVIRONMENT = process.env.ENVIRONMENT || 'miso';
-const TEST_APP_NAME = 'test-dataplane-down';
-
-/**
- * Creates wizard config file
- * @async
- * @function createWizardConfig
- * @param {string} configPath - Path to config file
- * @returns {Promise<void>} Resolves when config file is created
- */
-async function createWizardConfig(configPath) {
-  const configContent = `appName: ${TEST_APP_NAME}
-mode: create-system
-source:
-  type: known-platform
-  platform: hubspot
-deployment:
-  controller: ${CONTROLLER_URL}
-  environment: ${ENVIRONMENT}
-  dataplane: ${INVALID_DATAPLANE_URL}
-`;
-  await fs.writeFile(configPath, configContent, 'utf8');
-}
-
-/**
- * Test wizard command with invalid dataplane
- * @async
- * @function testWizard
- * @returns {Promise<Object>} Test result
- */
-async function testWizard() {
-  logInfo('\n📋 Testing: wizard command');
-
-  const configPath = path.join(process.cwd(), 'integration', 'test-wizard-config.yaml');
-
-  try {
-    await createWizardConfig(configPath);
-
-    const args = [
-      'bin/aifabrix.js',
-      'wizard',
-      '--config',
-      configPath
-    ];
-
-    const result = await runCommand('node', args);
-    const output = `${result.stdout}\n${result.stderr}`;
-
-    // Clean up config file
-    try {
-      await fs.unlink(configPath);
-    } catch {
-      // Ignore cleanup errors
-    }
-
-    return validateWizardResult(result, output);
-  } catch (error) {
-    return {
-      name: 'wizard',
-      success: false,
-      output: error.message,
-      error: error.message
-    };
-  }
-}
-
-/**
- * Test download command with invalid dataplane
- * @async
- * @function testDownload
- * @returns {Promise<Object>} Test result
- */
-async function testDownload() {
-  logInfo('\n📥 Testing: download command');
-
-  const args = [
-    'bin/aifabrix.js',
-    'download',
-    'non-existent-system-that-should-fail'
-  ];
-
-  const result = await runCommand('node', args);
-  const output = `${result.stdout}\n${result.stderr}`;
-
-  const expectedPatterns = [
-    'failed to connect',
-    'connection refused',
-    'network error',
-    'econnrefused',
-    'fetch failed',
-    'timeout',
-    'unreachable',
-    'failed to download system',
-    'not found',
-    'external system'
-  ];
-
-  const validation = validateDownloadDeleteResult(result, output, expectedPatterns);
-
-  return {
-    name: 'download',
-    success: validation.isValid,
-    output: validation.output,
-    expectedPatterns: validation.expectedPatterns
-  };
-}
-
-/**
- * Test delete command with invalid dataplane
- * @async
- * @function testDelete
- * @returns {Promise<Object>} Test result
- */
-async function testDelete() {
-  logInfo('\n🗑️  Testing: delete command');
-
-  const args = [
-    'bin/aifabrix.js',
-    'delete',
-    'non-existent-system-that-should-fail',
-    '--type',
-    'external',
-    '--yes'
-  ];
-
-  const result = await runCommand('node', args);
-  const output = `${result.stdout}\n${result.stderr}`;
-
-  const expectedPatterns = [
-    'failed to connect',
-    'connection refused',
-    'network error',
-    'econnrefused',
-    'fetch failed',
-    'timeout',
-    'unreachable',
-    'failed to delete',
-    'not found',
-    'external system'
-  ];
-
-  const validation = validateDeleteResult(result, output, expectedPatterns);
-
-  return {
-    name: 'delete',
-    success: validation.isValid,
-    output: validation.output,
-    expectedPatterns: validation.expectedPatterns,
-    error: validation.error
-  };
-}
-
-/**
- * Creates test datasource file
- * @async
- * @function createTestDatasource
- * @param {string} datasourcePath - Path to datasource file
- * @returns {Promise<void>} Resolves when datasource file is created
- */
-async function createTestDatasource(datasourcePath) {
-  const datasourceContent = JSON.stringify({
-    key: 'test-datasource',
-    systemKey: 'test-system',
-    displayName: 'Test Datasource',
-    entityType: 'company',
-    resourceType: 'company'
-  }, null, 2);
-  await fs.writeFile(datasourcePath, datasourceContent, 'utf8');
-}
-
-/**
- * Builds datasource upload command arguments
- * @function buildDatasourceUploadArgs
- * @param {string} datasourcePath - Path to datasource file
- * @returns {string[]} Command arguments
- */
-function buildDatasourceUploadArgs(datasourcePath) {
-  return ['bin/aifabrix.js', 'datasource', 'upload', datasourcePath];
-}
-
-/**
- * Gets expected error patterns for datasource upload
- * @function getDatasourceUploadErrorPatterns
- * @returns {string[]} Expected error patterns
- */
-function getDatasourceUploadErrorPatterns() {
-  return [
-    'failed to connect',
-    'connection refused',
-    'network error',
-    'econnrefused',
-    'fetch failed',
-    'timeout',
-    'unreachable',
-    'failed to publish',
-    'upload failed',
-    'deployment failed'
-  ];
-}
-
-/**
- * Test datasource upload command with invalid dataplane
- * @async
- * @function testDatasourceUpload
- * @returns {Promise<Object>} Test result
- */
-async function testDatasourceUpload() {
-  logInfo('\n🚀 Testing: datasource upload command');
-
-  const datasourcePath = path.join(process.cwd(), 'integration', 'test-datasource.json');
-
-  try {
-    await createTestDatasource(datasourcePath);
-    const args = buildDatasourceUploadArgs(datasourcePath);
-    const result = await runCommand('node', args);
-    const output = `${result.stdout}\n${result.stderr}`;
-
-    // Clean up datasource file
-    try {
-      await fs.unlink(datasourcePath);
-    } catch {
-      // Ignore cleanup errors
-    }
-
-    const expectedPatterns = getDatasourceUploadErrorPatterns();
-    const isValid = !result.success && validateError(output, expectedPatterns);
-
-    return {
-      name: 'datasource upload',
-      success: isValid,
-      output,
-      expectedPatterns
-    };
-  } catch (error) {
-    return {
-      name: 'datasource upload',
-      success: false,
-      output: error.message,
-      error: error.message
-    };
-  }
-}
-
-/**
- * Determines test app name for integration test
- * @async
- * @function determineTestApp
- * @returns {Promise<string>} Test app name
- */
-async function determineTestApp() {
-  const hubspotPath = path.join(process.cwd(), 'integration', 'hubspot');
-  try {
-    await fs.access(hubspotPath);
-    return 'hubspot';
-  } catch {
-    return 'non-existent-app';
-  }
-}
-
-/**
- * Test test-integration command with invalid dataplane
- * @async
- * @function testIntegration
- * @returns {Promise<Object>} Test result
- */
-async function testIntegration() {
-  logInfo('\n🧪 Testing: test-integration command');
-
-  const testApp = await determineTestApp();
-
-  const args = [
-    'bin/aifabrix.js',
-    'test-integration',
-    testApp
-  ];
-
-  const result = await runCommand('node', args);
-  const output = `${result.stdout}\n${result.stderr}`;
-
-  const expectedPatterns = [
-    'failed to connect',
-    'connection refused',
-    'network error',
-    'econnrefused',
-    'fetch failed',
-    'timeout',
-    'unreachable',
-    'failed to run integration tests',
-    'not found',
-    'dataplane url not found',
-    'application not found'
-  ];
-
-  const isValid = !result.success && (
-    validateError(output, expectedPatterns) ||
-    output.includes('Failed') ||
-    output.includes('Error') ||
-    output.includes('not found')
-  );
-
-  return {
-    name: 'test-integration',
-    success: isValid,
-    output,
-    expectedPatterns
-  };
-}
-
-/**
- * Test dataplane discovery with invalid dataplane
- * @async
- * @function testDataplaneDiscovery
- * @returns {Promise<Object>} Test result
- */
-async function testDataplaneDiscovery() {
-  logInfo('\n🌐 Testing: dataplane discovery');
-
-  const args = [
-    'bin/aifabrix.js',
-    'download',
-    'non-existent-system-for-discovery-test'
-  ];
-
-  const result = await runCommand('node', args);
-  const output = `${result.stdout}\n${result.stderr}`;
-
-  const expectedPatterns = [
-    'failed to discover dataplane url',
-    'dataplane service not found',
-    'application not found',
-    'dataplane url not found',
-    'failed to download system',
-    'not found',
-    'external system'
-  ];
-
-  const timeout = isTimeoutResult(result);
-  const isValid = (!result.success || timeout) && (
-    timeout ||
-    validateError(output, expectedPatterns) ||
-    output.includes('not found') ||
-    output.includes('Failed') ||
-    output.includes('Error')
-  );
-
-  return {
-    name: 'dataplane discovery',
-    success: isValid,
-    output: timeout ? `${output}\n[Command timed out - this indicates the command may be hanging]` : output,
-    expectedPatterns: timeout ? [...expectedPatterns, 'timeout'] : expectedPatterns
-  };
-}
-
-module.exports = {
-  testWizard,
-  testDownload,
-  testDelete,
-  testDatasourceUpload,
-  testIntegration,
-  testDataplaneDiscovery
-};

package/integration/hubspot-test/test-dataplane-down.js

@@ -1,209 +0,0 @@
-#!/usr/bin/env node
-/**
- * Dataplane Down Test Suite
- *
- * Tests all commands that interact with dataplane when dataplane is unavailable.
- * Validates that appropriate error messages are returned.
- *
- * @fileoverview Dataplane down error handling tests
- * @author AI Fabrix Team
- * @version 2.0.0
- */
-'use strict';
-
-const fs = require('fs').promises;
-const path = require('path');
-const os = require('os');
-const {
-  logInfo,
-  logSuccess,
-  logError,
-  logWarn
-} = require('./test-dataplane-down-helpers');
-const {
-  testWizard,
-  testDownload,
-  testDelete,
-  testDatasourceUpload,
-  testIntegration,
-  testDataplaneDiscovery
-} = require('./test-dataplane-down-tests');
-
-const INVALID_DATAPLANE_URL = 'http://localhost:9999';
-const ENVIRONMENT = process.env.ENVIRONMENT || 'miso';
-
-/** Path to temp config used so CLI uses invalid controller URL and fails with connection error */
-let tempConfigPath = null;
-let originalAifabrixConfig = null;
-
-/**
- * Create temp config pointing controller to invalid URL so commands fail with connection error
- * @async
- * @returns {Promise<string>} Path to temp config file
- */
-async function createTempConfig() {
-  const dir = path.join(os.tmpdir(), `aifabrix-dataplane-down-${Date.now()}`);
-  await fs.mkdir(dir, { recursive: true });
-  const configPath = path.join(dir, 'config.yaml');
-  const content = `controller: "${INVALID_DATAPLANE_URL}"
-environment: "${ENVIRONMENT}"
-`;
-  await fs.writeFile(configPath, content, 'utf8');
-  return configPath;
-}
-
-/**
- * Restore AIFABRIX_CONFIG and remove temp config
- * @async
- * @returns {Promise<void>} Resolves when cleanup is complete
- */
-async function cleanupTempConfig() {
-  if (originalAifabrixConfig !== undefined) {
-    if (originalAifabrixConfig === null) {
-      delete process.env.AIFABRIX_CONFIG;
-    } else {
-      process.env.AIFABRIX_CONFIG = originalAifabrixConfig;
-    }
-  }
-  if (tempConfigPath) {
-    try {
-      await fs.rm(path.dirname(tempConfigPath), { recursive: true, force: true }).catch(() => {});
-    } catch {
-      // Ignore cleanup errors
-    }
-    tempConfigPath = null;
-  }
-}
-
-/**
- * Displays failed test details
- * @function displayFailedTestDetails
- * @param {Array} failedTests - Failed test results
- * @returns {void}
- */
-function displayFailedTestDetails(failedTests) {
-  if (failedTests.length === 0) {
-    return;
-  }
-
-  logError('\nFailed Tests:');
-  for (const test of failedTests) {
-    logError(`  - ${test.name}`);
-    if (test.output) {
-      const outputPreview = test.output.length > 500 ? test.output.substring(0, 500) + '...' : test.output;
-      logWarn(`    Output: ${outputPreview}`);
-    }
-    if (test.error) {
-      logWarn(`    Error: ${test.error}`);
-    }
-    if (test.expectedPatterns) {
-      logWarn(`    Expected patterns: ${test.expectedPatterns.join(', ')}`);
-    }
-  }
-}
-
-/**
- * Displays test results summary
- * @function displaySummary
- * @param {Array} results - Test results
- * @returns {void}
- */
-function displaySummary(results) {
-  logInfo('\n' + '='.repeat(60));
-  logInfo('Test Summary');
-  logInfo('='.repeat(60));
-
-  const passed = results.filter(r => r.success).length;
-  const failed = results.filter(r => !r.success).length;
-
-  logInfo(`Total tests: ${results.length}`);
-  logSuccess(`Passed: ${passed}`);
-  if (failed > 0) {
-    logError(`Failed: ${failed}`);
-  }
-
-  const failedTests = results.filter(r => !r.success);
-  displayFailedTestDetails(failedTests);
-
-  logInfo('='.repeat(60));
-}
-
-/**
- * Runs all test cases
- * @async
- * @function runTests
- * @returns {Promise<Array>} Test results
- */
-async function runTests() {
-  const tests = [
-    testWizard,
-    testDownload,
-    testDelete,
-    testDatasourceUpload,
-    testIntegration,
-    testDataplaneDiscovery
-  ];
-
-  const results = [];
-
-  for (const testFn of tests) {
-    try {
-      const result = await testFn();
-      results.push(result);
-
-      if (result.success) {
-        logSuccess(`✔ ${result.name}: Error handling validated`);
-      } else {
-        logError(`✖ ${result.name}: Error handling failed`);
-        if (result.output) {
-          logWarn(`  Output: ${result.output.substring(0, 200)}...`);
-        }
-      }
-    } catch (error) {
-      logError(`✖ ${testFn.name}: Unexpected error: ${error.message}`);
-      results.push({
-        name: testFn.name,
-        success: false,
-        error: error.message
-      });
-    }
-  }
-
-  return results;
-}
-
-/**
- * Main test runner
- * @async
- * @function main
- * @returns {Promise<void>} Resolves when tests complete
- */
-async function main() {
-  logInfo('='.repeat(60));
-  logInfo('Dataplane Down Error Handling Test Suite');
-  logInfo('='.repeat(60));
-  logInfo(`Invalid Controller URL (used for all commands): ${INVALID_DATAPLANE_URL}`);
-  logInfo(`Environment: ${ENVIRONMENT}`);
-  logInfo('='.repeat(60));
-
-  try {
-    tempConfigPath = await createTempConfig();
-    originalAifabrixConfig = process.env.AIFABRIX_CONFIG || null;
-    process.env.AIFABRIX_CONFIG = tempConfigPath;
-
-    const results = await runTests();
-    displaySummary(results);
-
-    const failed = results.filter(r => !r.success).length;
-    if (failed > 0) {
-      process.exitCode = 1;
-    }
-  } finally {
-    await cleanupTempConfig();
-  }
-}
-
-main().catch(error => {
-  logError(`Fatal error: ${error.message}`);
-  process.exitCode = 1;
-});