@onlineapps/conn-orch-validator 2.0.0

package/src/mocks/MockMQClient.js

@@ -0,0 +1,176 @@
+'use strict';
+
+/**
+ * MockMQClient - Simulates RabbitMQ for testing
+ * Provides in-memory message queue simulation
+ */
+class MockMQClient {
+  constructor() {
+    this.queues = {};
+    this.consumers = {};
+    this.isConnected = false;
+    this.publishedMessages = [];
+    this.acknowledgedMessages = [];
+    this.rejectedMessages = [];
+  }
+
+  /**
+   * Simulate connection
+   */
+  async connect() {
+    this.isConnected = true;
+    return Promise.resolve();
+  }
+
+  /**
+   * Simulate disconnection
+   */
+  async disconnect() {
+    this.isConnected = false;
+    this.consumers = {};
+    return Promise.resolve();
+  }
+
+  /**
+   * Publish message to queue
+   */
+  async publish(queue, message, options = {}) {
+    if (!this.isConnected) {
+      throw new Error('Not connected to MQ');
+    }
+
+    if (!this.queues[queue]) {
+      this.queues[queue] = [];
+    }
+
+    const messageWrapper = {
+      content: Buffer.from(JSON.stringify(message)),
+      fields: { routingKey: queue },
+      properties: options,
+      timestamp: Date.now()
+    };
+
+    this.queues[queue].push(messageWrapper);
+    this.publishedMessages.push({ queue, message, options, timestamp: Date.now() });
+
+    // Trigger consumers if any
+    if (this.consumers[queue]) {
+      const consumer = this.consumers[queue];
+      setImmediate(() => {
+        consumer.callback(messageWrapper);
+      });
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Consume messages from queue
+   */
+  async consume(queue, callback, options = {}) {
+    if (!this.isConnected) {
+      throw new Error('Not connected to MQ');
+    }
+
+    this.consumers[queue] = {
+      callback,
+      options
+    };
+
+    // Process existing messages in queue
+    if (this.queues[queue]) {
+      const messages = [...this.queues[queue]];
+      this.queues[queue] = [];
+
+      messages.forEach(msg => {
+        setImmediate(() => callback(msg));
+      });
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Acknowledge message
+   */
+  async ack(message) {
+    this.acknowledgedMessages.push({
+      message,
+      timestamp: Date.now()
+    });
+    return Promise.resolve();
+  }
+
+  /**
+   * Reject message
+   */
+  async nack(message, allUpTo = false, requeue = false) {
+    this.rejectedMessages.push({
+      message,
+      allUpTo,
+      requeue,
+      timestamp: Date.now()
+    });
+
+    if (requeue && message.fields) {
+      const queue = message.fields.routingKey;
+      if (this.queues[queue]) {
+        this.queues[queue].push(message);
+      }
+    }
+
+    return Promise.resolve();
+  }
+
+  /**
+   * Get messages from queue (for testing)
+   */
+  getMessages(queue) {
+    return (this.queues[queue] || []).map(msg =>
+      JSON.parse(msg.content.toString())
+    );
+  }
+
+  /**
+   * Get all published messages (for testing)
+   */
+  getPublishedMessages(queue = null) {
+    if (queue) {
+      return this.publishedMessages.filter(m => m.queue === queue);
+    }
+    return this.publishedMessages;
+  }
+
+  /**
+   * Clear all data (for testing)
+   */
+  clear() {
+    this.queues = {};
+    this.publishedMessages = [];
+    this.acknowledgedMessages = [];
+    this.rejectedMessages = [];
+  }
+
+  /**
+   * Get statistics (for testing)
+   */
+  getStats() {
+    return {
+      queues: Object.keys(this.queues),
+      messageCount: Object.values(this.queues).reduce((sum, q) => sum + q.length, 0),
+      published: this.publishedMessages.length,
+      acknowledged: this.acknowledgedMessages.length,
+      rejected: this.rejectedMessages.length,
+      consumers: Object.keys(this.consumers)
+    };
+  }
+
+  /**
+   * Simulate message processing delay
+   */
+  async simulateDelay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+module.exports = MockMQClient;

package/src/mocks/MockRegistry.js

@@ -0,0 +1,164 @@
+'use strict';
+
+/**
+ * MockRegistry - Simulates service registry for testing
+ */
+class MockRegistry {
+  constructor() {
+    this.services = {};
+    this.certificates = {};
+    this.heartbeats = {};
+    this.validationResults = {};
+  }
+
+  /**
+   * Register a service
+   */
+  async register(serviceData) {
+    const { name, version, url, healthCheck, openapi } = serviceData;
+
+    if (!name) {
+      throw new Error('Service name is required');
+    }
+
+    this.services[name] = {
+      name,
+      version: version || '1.0.0',
+      url: url || `http://localhost:3000`,
+      healthCheck: healthCheck || '/health',
+      openapi: openapi || {},
+      registeredAt: Date.now(),
+      status: 'active'
+    };
+
+    // Issue mock certificate
+    this.certificates[name] = {
+      serviceId: name,
+      issuedAt: Date.now(),
+      expiresAt: Date.now() + 86400000, // 24 hours
+      fingerprint: `mock-cert-${name}-${Date.now()}`
+    };
+
+    return {
+      success: true,
+      certificate: this.certificates[name]
+    };
+  }
+
+  /**
+   * Unregister a service
+   */
+  async unregister(serviceName) {
+    delete this.services[serviceName];
+    delete this.certificates[serviceName];
+    delete this.heartbeats[serviceName];
+    return { success: true };
+  }
+
+  /**
+   * Send heartbeat
+   */
+  async heartbeat(serviceName) {
+    if (!this.services[serviceName]) {
+      throw new Error(`Service ${serviceName} not registered`);
+    }
+
+    this.heartbeats[serviceName] = {
+      timestamp: Date.now(),
+      status: 'healthy'
+    };
+
+    return { success: true };
+  }
+
+  /**
+   * Get service by name
+   */
+  getService(serviceName) {
+    return this.services[serviceName] || null;
+  }
+
+  /**
+   * Get all services
+   */
+  getServices() {
+    return Object.values(this.services);
+  }
+
+  /**
+   * Get certificate for service
+   */
+  getCertificate(serviceName) {
+    return this.certificates[serviceName] || null;
+  }
+
+  /**
+   * Simulate validation
+   */
+  async validate(serviceName, validationData) {
+    this.validationResults[serviceName] = {
+      ...validationData,
+      timestamp: Date.now(),
+      passed: true
+    };
+
+    return {
+      success: true,
+      token: `validation-token-${serviceName}-${Date.now()}`
+    };
+  }
+
+  /**
+   * Get validation results
+   */
+  getValidationResults(serviceName) {
+    return this.validationResults[serviceName] || null;
+  }
+
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.services = {};
+    this.certificates = {};
+    this.heartbeats = {};
+    this.validationResults = {};
+  }
+
+  /**
+   * Get registry stats
+   */
+  getStats() {
+    return {
+      serviceCount: Object.keys(this.services).length,
+      activeServices: Object.values(this.services).filter(s => s.status === 'active').length,
+      certificates: Object.keys(this.certificates).length,
+      recentHeartbeats: Object.values(this.heartbeats).filter(
+        h => Date.now() - h.timestamp < 60000
+      ).length
+    };
+  }
+
+  /**
+   * Simulate service discovery
+   */
+  discover(query = {}) {
+    let results = Object.values(this.services);
+
+    if (query.name) {
+      results = results.filter(s => s.name.includes(query.name));
+    }
+
+    if (query.version) {
+      results = results.filter(s => s.version === query.version);
+    }
+
+    if (query.status) {
+      results = results.filter(s => s.status === query.status);
+    }
+
+    return results;
+  }
+}
+
+module.exports = MockRegistry;

package/src/mocks/MockStorage.js

@@ -0,0 +1,186 @@
+'use strict';
+
+/**
+ * MockStorage - Simulates MinIO/S3 storage for testing
+ */
+class MockStorage {
+  constructor() {
+    this.buckets = {};
+    this.metadata = {};
+  }
+
+  /**
+   * Create bucket
+   */
+  async createBucket(bucketName) {
+    if (!this.buckets[bucketName]) {
+      this.buckets[bucketName] = {};
+    }
+    return { success: true };
+  }
+
+  /**
+   * Put object
+   */
+  async put(bucket, key, content, options = {}) {
+    if (!this.buckets[bucket]) {
+      await this.createBucket(bucket);
+    }
+
+    const data = typeof content === 'object' ? JSON.stringify(content) : content;
+
+    this.buckets[bucket][key] = {
+      content: data,
+      contentType: options.contentType || 'application/json',
+      metadata: options.metadata || {},
+      timestamp: Date.now(),
+      size: data.length
+    };
+
+    // Store metadata separately for querying
+    if (!this.metadata[bucket]) {
+      this.metadata[bucket] = {};
+    }
+    this.metadata[bucket][key] = {
+      size: data.length,
+      lastModified: Date.now(),
+      contentType: options.contentType || 'application/json'
+    };
+
+    return {
+      success: true,
+      etag: `mock-etag-${Date.now()}`,
+      location: `${bucket}/${key}`
+    };
+  }
+
+  /**
+   * Get object
+   */
+  async get(bucket, key) {
+    if (!this.buckets[bucket] || !this.buckets[bucket][key]) {
+      throw new Error(`Object not found: ${bucket}/${key}`);
+    }
+
+    const obj = this.buckets[bucket][key];
+    let content = obj.content;
+
+    // Try to parse JSON if content type suggests it
+    if (obj.contentType === 'application/json' && typeof content === 'string') {
+      try {
+        content = JSON.parse(content);
+      } catch (e) {
+        // Keep as string if parsing fails
+      }
+    }
+
+    return {
+      content,
+      metadata: obj.metadata,
+      contentType: obj.contentType,
+      size: obj.size,
+      lastModified: obj.timestamp
+    };
+  }
+
+  /**
+   * Delete object
+   */
+  async delete(bucket, key) {
+    if (this.buckets[bucket]) {
+      delete this.buckets[bucket][key];
+      if (this.metadata[bucket]) {
+        delete this.metadata[bucket][key];
+      }
+    }
+    return { success: true };
+  }
+
+  /**
+   * List objects in bucket
+   */
+  async list(bucket, prefix = '', limit = 1000) {
+    if (!this.buckets[bucket]) {
+      return { objects: [] };
+    }
+
+    const objects = Object.keys(this.buckets[bucket])
+      .filter(key => key.startsWith(prefix))
+      .slice(0, limit)
+      .map(key => ({
+        key,
+        size: this.buckets[bucket][key].size,
+        lastModified: this.buckets[bucket][key].timestamp
+      }));
+
+    return { objects };
+  }
+
+  /**
+   * Check if object exists
+   */
+  async exists(bucket, key) {
+    return !!(this.buckets[bucket] && this.buckets[bucket][key]);
+  }
+
+  /**
+   * Get object metadata
+   */
+  async getMetadata(bucket, key) {
+    if (!this.metadata[bucket] || !this.metadata[bucket][key]) {
+      throw new Error(`Metadata not found: ${bucket}/${key}`);
+    }
+    return this.metadata[bucket][key];
+  }
+
+  /**
+   * Generate presigned URL (mock)
+   */
+  async getPresignedUrl(bucket, key, expiresIn = 3600) {
+    return {
+      url: `http://mock-storage/${bucket}/${key}?token=mock-token-${Date.now()}`,
+      expiresAt: Date.now() + (expiresIn * 1000)
+    };
+  }
+
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.buckets = {};
+    this.metadata = {};
+  }
+
+  /**
+   * Get storage stats
+   */
+  getStats() {
+    const stats = {
+      bucketCount: Object.keys(this.buckets).length,
+      totalObjects: 0,
+      totalSize: 0
+    };
+
+    Object.values(this.buckets).forEach(bucket => {
+      Object.values(bucket).forEach(obj => {
+        stats.totalObjects++;
+        stats.totalSize += obj.size;
+      });
+    });
+
+    return stats;
+  }
+
+  /**
+   * Copy object
+   */
+  async copy(sourceBucket, sourceKey, destBucket, destKey) {
+    const source = await this.get(sourceBucket, sourceKey);
+    return await this.put(destBucket, destKey, source.content, {
+      contentType: source.contentType,
+      metadata: source.metadata
+    });
+  }
+}
+
+module.exports = MockStorage;