@onlineapps/infrastructure-tools 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/infrastructure-tools",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Infrastructure orchestration utilities for OA Drive infrastructure services (health tracking, queue initialization, service discovery)",
   "main": "src/index.js",
   "scripts": {

package/src/orchestration/waitForInfrastructureReady.js

@@ -42,13 +42,30 @@ async function waitForInfrastructureReady(options = {}) {
   const checkInterval = options.checkInterval || parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL) || 5000; // 5 seconds
   const logger = options.logger || console;
 
+  // Universal logger adapter (supports both console and winston)
+  // Winston logger expects object with message property, console.log accepts string
+  const log = (message) => {
+    if (typeof logger.info === 'function' && typeof logger.log !== 'function') {
+      // Likely winston logger - use object format
+      logger.info({ message: String(message) });
+    } else if (typeof logger.log === 'function') {
+      // console.log or similar
+      logger.log(message);
+    } else if (typeof logger.info === 'function') {
+      // Fallback for other loggers
+      logger.info(message);
+    } else {
+      console.log(message);
+    }
+  };
+
   const startTime = Date.now();
   let attemptCount = 0;
   let redis = null;
 
-  logger.log('[InfrastructureReady] Waiting for all infrastructure services to be ready...');
-  logger.log(`[InfrastructureReady] Redis URL: ${redisUrl}`);
-  logger.log(`[InfrastructureReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
+  log('[InfrastructureReady] Waiting for all infrastructure services to be ready...');
+  log(`[InfrastructureReady] Redis URL: ${redisUrl}`);
+  log(`[InfrastructureReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
 
   try {
     // Connect to Redis
@@ -56,11 +73,11 @@ async function waitForInfrastructureReady(options = {}) {
     redis = createClient({ url: redisUrl });
     
     redis.on('error', (err) => {
-      logger.log(`[InfrastructureReady] Redis error: ${err.message}`);
+      log(`[InfrastructureReady] Redis error: ${err.message}`);
     });
     
     await redis.connect();
-    logger.log('[InfrastructureReady] Connected to Redis');
+    log('[InfrastructureReady] Connected to Redis');
 
     while (Date.now() - startTime < maxWait) {
       attemptCount++;
@@ -72,7 +89,7 @@ async function waitForInfrastructureReady(options = {}) {
         if (allHealthy === 'true') {
           // All services are UP, we can proceed
           const elapsed = Date.now() - startTime;
-          logger.log(`[InfrastructureReady] ✓ All infrastructure services are ready (took ${elapsed}ms, ${attemptCount} attempts)`);
+          log(`[InfrastructureReady] ✓ All infrastructure services are ready (took ${elapsed}ms, ${attemptCount} attempts)`);
           
           // Optionally log individual service status
           // Note: Service names should match config.infrastructureServices in Registry
@@ -84,19 +101,19 @@ async function waitForInfrastructureReady(options = {}) {
               statuses[serviceName] = JSON.parse(status);
             }
           }
-          logger.log(`[InfrastructureReady] Infrastructure status:`, JSON.stringify(statuses, null, 2));
+          log(`[InfrastructureReady] Infrastructure status: ${JSON.stringify(statuses, null, 2)}`);
           
           return true;
         }
 
         // Not all services ready yet
-        logger.log(`[InfrastructureReady] Attempt ${attemptCount}: Not all services ready (allHealthy: ${allHealthy || 'null'})`);
-        logger.log(`[InfrastructureReady] Waiting ${checkInterval}ms before next check...`);
+        log(`[InfrastructureReady] Attempt ${attemptCount}: Not all services ready (allHealthy: ${allHealthy || 'null'})`);
+        log(`[InfrastructureReady] Waiting ${checkInterval}ms before next check...`);
 
       } catch (error) {
         // Redis might not be ready yet, or connection issue
-        logger.log(`[InfrastructureReady] Attempt ${attemptCount}: Redis check failed (${error.message})`);
-        logger.log(`[InfrastructureReady] Waiting ${checkInterval}ms before retry...`);
+        log(`[InfrastructureReady] Attempt ${attemptCount}: Redis check failed (${error.message})`);
+        log(`[InfrastructureReady] Waiting ${checkInterval}ms before retry...`);
       }
 
       // Wait before next check
@@ -114,7 +131,7 @@ async function waitForInfrastructureReady(options = {}) {
     // Clean up Redis connection
     if (redis && redis.isReady) {
       await redis.quit();
-      logger.log('[InfrastructureReady] Redis connection closed');
+      log('[InfrastructureReady] Redis connection closed');
     }
   }
 }

package/test-integration.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Integration test for infrastructure-tools
+ * Tests all components: healthPublisher, waitForInfrastructureReady, initInfrastructureQueues
+ */
+
+const {
+  createHealthPublisher,
+  createBaseClientAdapter,
+  createAmqplibAdapter,
+  waitForInfrastructureReady,
+  initInfrastructureQueues
+} = require('./src/index');
+
+console.log('🧪 Testing @onlineapps/infrastructure-tools\n');
+
+// Test 1: Check exports
+console.log('Test 1: Checking exports...');
+const exportTypes = {
+  createHealthPublisher: typeof createHealthPublisher,
+  createBaseClientAdapter: typeof createBaseClientAdapter,
+  createAmqplibAdapter: typeof createAmqplibAdapter,
+  waitForInfrastructureReady: typeof waitForInfrastructureReady,
+  initInfrastructureQueues: typeof initInfrastructureQueues
+};
+
+let allExportsOk = true;
+for (const [name, type] of Object.entries(exportTypes)) {
+  if (type !== 'function') {
+    console.error(`  ✗ ${name} is not a function (got ${type})`);
+    allExportsOk = false;
+  } else {
+    console.log(`  ✓ ${name} is a function`);
+  }
+}
+
+if (!allExportsOk) {
+  console.error('\n❌ Export test failed');
+  process.exit(1);
+}
+
+console.log('✓ All exports are functions\n');
+
+// Test 2: Test createHealthPublisher with mock
+async function testHealthPublisher() {
+  console.log('Test 2: Testing createHealthPublisher with mock publish function...');
+  let publishedMessages = [];
+  const mockPublish = async (queueName, data) => {
+    publishedMessages.push({ queueName, data, timestamp: new Date().toISOString() });
+  };
+
+  const mockGetHealthData = () => ({
+    mq: 'healthy',
+    redis: 'healthy',
+    http: 'healthy'
+  });
+
+  try {
+    const publisher = createHealthPublisher({
+      serviceName: 'test-service',
+      version: '1.0.0',
+      publishFunction: mockPublish,
+      getHealthData: mockGetHealthData,
+      config: {
+        queueName: 'test.health.checks',
+        publishInterval: 100
+      },
+      logger: {
+        log: () => {},
+        warn: () => {},
+        error: () => {},
+        debug: () => {},
+        info: () => {}
+      }
+    });
+
+    // Test immediate publish
+    await publisher.publishNow();
+    if (publishedMessages.length !== 1) {
+      throw new Error(`Expected 1 published message, got ${publishedMessages.length}`);
+    }
+    if (publishedMessages[0].data.serviceName !== 'test-service') {
+      throw new Error(`Expected serviceName 'test-service', got '${publishedMessages[0].data.serviceName}'`);
+    }
+    console.log('  ✓ publishNow() works');
+
+    // Test start/stop
+    await publisher.start();
+    await new Promise(resolve => setTimeout(resolve, 250)); // Wait for 2 intervals
+    publisher.stop();
+    
+    if (publishedMessages.length < 2) {
+      throw new Error(`Expected at least 2 published messages, got ${publishedMessages.length}`);
+    }
+    console.log('  ✓ start/stop works');
+    console.log(`  ✓ Published ${publishedMessages.length} messages total`);
+
+    console.log('✓ createHealthPublisher test passed\n');
+  } catch (error) {
+    console.error(`  ✗ createHealthPublisher test failed: ${error.message}`);
+    throw error;
+  }
+}
+
+// Test 3: Test waitForInfrastructureReady (mock Redis)
+console.log('Test 3: Testing waitForInfrastructureReady with mock Redis...');
+// This test would require Redis connection, so we'll just check that function exists
+if (typeof waitForInfrastructureReady === 'function') {
+  console.log('  ✓ waitForInfrastructureReady is a function');
+} else {
+  console.error(`  ✗ waitForInfrastructureReady is not a function`);
+  process.exit(1);
+}
+console.log('  ⚠ Skipping actual Redis test (requires Redis connection)\n');
+
+// Test 4: Test initInfrastructureQueues (mock channel)
+console.log('Test 4: Testing initInfrastructureQueues with mock channel...');
+// This test would require RabbitMQ connection, so we'll just check that function exists
+if (typeof initInfrastructureQueues === 'function') {
+  console.log('  ✓ initInfrastructureQueues is a function');
+} else {
+  console.error(`  ✗ initInfrastructureQueues is not a function`);
+  process.exit(1);
+}
+console.log('  ⚠ Skipping actual RabbitMQ test (requires RabbitMQ connection)\n');
+
+// Run async tests
+(async () => {
+  try {
+    await testHealthPublisher();
+    
+    console.log('✅ All tests passed!');
+    console.log('\nNote: Full integration tests require:');
+    console.log('  - Redis connection (for waitForInfrastructureReady)');
+    console.log('  - RabbitMQ connection (for initInfrastructureQueues)');
+    console.log('  - Running infrastructure services (for end-to-end testing)');
+  } catch (error) {
+    console.error('\n❌ Tests failed:', error.message);
+    process.exit(1);
+  }
+})();
+