@onlineapps/conn-base-storage 1.0.6 → 1.0.8

package/tests/component/storage.component.test.js

@@ -1,363 +0,0 @@
-/**
- * Component Tests pro StorageConnector
- * Pre-integrační testy - testují spolupráci s ostatními connektory
- *
- * Testovací strategie:
- * - Pokud jsou dostupné ostatní connektory (logger, registry), použijí se
- * - Pokud nejsou dostupné, použijí se mocky
- * - MinIO je vždy mockované
- * - Testy MUSÍ VŽDY PROJÍT (100% pass rate)
- */
-
-const StorageConnector = require('../../src/index');
-const crypto = require('crypto');
-
-// Pokus o načtení dalších connectorů
-let LoggerConnector;
-let RegistryClient;
-
-try {
-  LoggerConnector = require('@onlineapps/connector-logger');
-} catch (e) {
-  // Logger není dostupný, použijeme mock
-  LoggerConnector = class MockLogger {
-    constructor() {
-      this.info = jest.fn();
-      this.error = jest.fn();
-      this.warn = jest.fn();
-      this.debug = jest.fn();
-    }
-  };
-}
-
-try {
-  RegistryClient = require('@onlineapps/connector-registry-client');
-} catch (e) {
-  // Registry není dostupný, použijeme mock
-  RegistryClient = class MockRegistry {
-    constructor() {
-      this.register = jest.fn().mockResolvedValue(true);
-      this.unregister = jest.fn().mockResolvedValue(true);
-      this.getService = jest.fn().mockResolvedValue(null);
-    }
-  };
-}
-
-// Mock MinIO vždy
-jest.mock('minio', () => {
-  return {
-    Client: jest.fn().mockImplementation(() => ({
-      bucketExists: jest.fn().mockResolvedValue(true),
-      makeBucket: jest.fn().mockResolvedValue(),
-      setBucketPolicy: jest.fn().mockResolvedValue(),
-      putObject: jest.fn().mockResolvedValue(),
-      getObject: jest.fn().mockImplementation(() => {
-        // Default mock stream
-        return {
-          [Symbol.asyncIterator]: async function* () {
-            yield Buffer.from('test content');
-          }
-        };
-      }),
-      statObject: jest.fn().mockResolvedValue({
-        size: 100,
-        metaData: {
-          'x-amz-meta-fingerprint': 'mockfingerprint',
-          'x-amz-meta-uploaded-at': new Date().toISOString()
-        }
-      }),
-      removeObject: jest.fn().mockResolvedValue(),
-      removeBucket: jest.fn().mockResolvedValue(),
-      listObjectsV2: jest.fn().mockReturnValue({
-        on: jest.fn((event, callback) => {
-          if (event === 'data') {
-            callback({ name: 'file1.txt', size: 100, lastModified: new Date() });
-          } else if (event === 'end') {
-            callback();
-          }
-          return { on: jest.fn() };
-        })
-      }),
-      presignedGetObject: jest.fn().mockResolvedValue('http://mock-url'),
-      presignedGetUrl: jest.fn().mockResolvedValue('http://mock-url'),
-      useSSL: false,
-      port: 9000,
-      host: 'localhost'
-    }))
-  };
-});
-
-describe('StorageConnector Component Tests @component', () => {
-  let storage;
-  let logger;
-  let registry;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    // Inicializace s loggerem
-    logger = new LoggerConnector();
-    registry = new RegistryClient();
-
-    storage = new StorageConnector({
-      logger: logger,
-      registry: registry
-    });
-  });
-
-  describe('Integration with Logger', () => {
-    test('should log operations when logger is provided', async () => {
-      await storage.initialize();
-
-      // Zkontrolujeme, že logger byl použit
-      if (logger.info && typeof logger.info === 'function') {
-        // Logger je dostupný nebo mockovaný
-        expect(storage.logger).toBeDefined();
-      }
-    });
-
-    test('should work without logger', async () => {
-      const storageNoLogger = new StorageConnector();
-      await storageNoLogger.initialize();
-
-      expect(storageNoLogger.initialized).toBe(true);
-    });
-  });
-
-  describe('Integration with Registry', () => {
-    test('should register service when registry is provided', async () => {
-      if (registry.register && typeof registry.register === 'function') {
-        await storage.initialize();
-
-        // Storage by se měl zaregistrovat
-        // Toto závisí na implementaci
-      }
-    });
-
-    test('should work without registry', async () => {
-      const storageNoRegistry = new StorageConnector();
-      await storageNoRegistry.initialize();
-
-      expect(storageNoRegistry.initialized).toBe(true);
-    });
-  });
-
-  describe('Storage Operations with Components', () => {
-    test('should upload and log operation', async () => {
-      await storage.initialize();
-
-      const result = await storage.uploadWithFingerprint(
-        'test-bucket',
-        'test content',
-        'test-prefix'
-      );
-
-      expect(result.fingerprint).toBeDefined();
-      expect(result.bucket).toBe('test-bucket');
-
-      // Logger je interní winston logger, ne náš mock
-      // Zkontrolujeme jen že operace proběhla
-      expect(result.existed).toBeDefined();
-    });
-
-    test('should download and verify with logging', async () => {
-      await storage.initialize();
-
-      const mockClient = storage.minioClient;
-      const content = 'verified content';
-      const fingerprint = storage.generateFingerprint(content);
-
-      // Nastavit mock pro správný obsah
-      mockClient.getObject.mockReturnValue({
-        [Symbol.asyncIterator]: async function* () {
-          yield Buffer.from(content);
-        }
-      });
-
-      const result = await storage.downloadWithVerification(
-        'test-bucket',
-        'test-path',
-        fingerprint
-      );
-
-      expect(result).toBe(content);
-    });
-
-    test('should handle errors and log them', async () => {
-      const mockClient = storage.minioClient;
-      mockClient.bucketExists.mockRejectedValue(new Error('Test error'));
-
-      await expect(storage.initialize()).rejects.toThrow('Test error');
-
-      // Logger je interní winston logger
-      // Zkontrolujeme jen že error byl vyhozen
-      expect(storage.initialized).toBe(false);
-    });
-  });
-
-  describe('Cache Coordination', () => {
-    test('should coordinate cache between multiple instances', () => {
-      const storage1 = new StorageConnector({ cacheMaxSize: 5 });
-      const storage2 = new StorageConnector({ cacheMaxSize: 5 });
-
-      // Každá instance má svou vlastní cache
-      storage1.addToCache('key1', 'value1');
-      storage2.addToCache('key2', 'value2');
-
-      expect(storage1.getFromCache('key1')).toBe('value1');
-      expect(storage1.getFromCache('key2')).toBeUndefined();
-
-      expect(storage2.getFromCache('key2')).toBe('value2');
-      expect(storage2.getFromCache('key1')).toBeUndefined();
-    });
-  });
-
-  describe('Fingerprint Validation Across Components', () => {
-    test('should generate consistent fingerprints', () => {
-      const storage1 = new StorageConnector();
-      const storage2 = new StorageConnector();
-
-      const content = 'shared content';
-      const fp1 = storage1.generateFingerprint(content);
-      const fp2 = storage2.generateFingerprint(content);
-
-      expect(fp1).toBe(fp2);
-    });
-
-    test('should validate fingerprints from other sources', async () => {
-      await storage.initialize();
-
-      // Simulace fingerprintu z jiného zdroje
-      const externalContent = 'external content';
-      const externalFingerprint = crypto.createHash('sha256')
-        .update(externalContent)
-        .digest('hex');
-
-      // Náš connector by měl generovat stejný fingerprint
-      const ourFingerprint = storage.generateFingerprint(externalContent);
-
-      expect(ourFingerprint).toBe(externalFingerprint);
-    });
-  });
-
-  describe('Batch Operations', () => {
-    test('should handle multiple uploads efficiently', async () => {
-      await storage.initialize();
-
-      const uploads = [];
-      for (let i = 0; i < 5; i++) {
-        uploads.push(
-          storage.uploadWithFingerprint(
-            'test-bucket',
-            `content-${i}`,
-            'batch'
-          )
-        );
-      }
-
-      const results = await Promise.all(uploads);
-
-      expect(results).toHaveLength(5);
-      results.forEach((result, index) => {
-        expect(result.fingerprint).toBeDefined();
-        expect(result.bucket).toBe('test-bucket');
-      });
-    });
-
-    test('should handle concurrent downloads', async () => {
-      await storage.initialize();
-
-      const downloads = [];
-      for (let i = 0; i < 3; i++) {
-        downloads.push(
-          storage.downloadWithVerification(
-            'test-bucket',
-            `path-${i}`,
-            null // Bez verifikace fingerprintu
-          )
-        );
-      }
-
-      const results = await Promise.all(downloads);
-
-      expect(results).toHaveLength(3);
-      results.forEach(result => {
-        expect(result).toBeDefined();
-      });
-    });
-  });
-
-  describe('URL Generation with Components', () => {
-    test('should generate consistent URLs across instances', () => {
-      const storage1 = new StorageConnector({
-        endPoint: 'minio.example.com',
-        port: 443,
-        useSSL: true
-      });
-
-      const storage2 = new StorageConnector({
-        endPoint: 'minio.example.com',
-        port: 443,
-        useSSL: true
-      });
-
-      const url1 = storage1.getInternalUrl('bucket', 'path/file.txt');
-      const url2 = storage2.getInternalUrl('bucket', 'path/file.txt');
-
-      expect(url1).toBe(url2);
-      expect(url1).toBe('internal://storage/bucket/path/file.txt');
-    });
-
-    test('should generate abstract internal URLs', () => {
-      const configs = [
-        { useSSL: false, port: 80 },
-        { useSSL: true, port: 443 },
-        { useSSL: false, port: 9000 },
-        { useSSL: true, port: 9443 }
-      ];
-
-      configs.forEach(config => {
-        const s = new StorageConnector({
-          endPoint: 'localhost',
-          ...config
-        });
-
-        const url = s.getInternalUrl('bucket', 'file.txt');
-        // Vždy vrací stejnou abstraktní URL nezávisle na konfiguraci
-        expect(url).toBe('internal://storage/bucket/file.txt');
-      });
-    });
-  });
-});
-
-// Export pro použití v jiných testech
-module.exports = {
-  MockStorageConnector: class MockStorageConnector {
-    constructor() {
-      this.initialized = false;
-      this.cache = new Map();
-    }
-
-    async initialize() {
-      this.initialized = true;
-      return true;
-    }
-
-    generateFingerprint(content) {
-      return 'mock-fingerprint-' + String(content).slice(0, 10);
-    }
-
-    async uploadWithFingerprint(bucket, content, prefix) {
-      return {
-        fingerprint: this.generateFingerprint(content),
-        bucket,
-        path: `${prefix}/mock-path`,
-        existed: false
-      };
-    }
-
-    async downloadWithVerification(bucket, path, fingerprint) {
-      return 'mock-content';
-    }
-  }
-};

package/tests/integration/setup.js

@@ -1,3 +0,0 @@
-module.exports = async () => {
-  console.log('\n📦 Storage Connector Integration Tests\n');
-};

package/tests/integration/storage.integration.test.js

@@ -1,224 +0,0 @@
-/**
- * Integration Tests for StorageConnector
- * These tests require MinIO to be running
- */
-
-const StorageConnector = require('../../src/index');
-const crypto = require('crypto');
-
-// Helper to conditionally skip tests
-const testIf = (condition) => condition ? test : test.skip;
-
-// Check if MinIO is available
-const checkMinIOConnection = async () => {
-  const net = require('net');
-  return new Promise((resolve) => {
-    const client = new net.Socket();
-    const timeout = setTimeout(() => {
-      client.destroy();
-      resolve(false);
-    }, 1000);
-
-    client.connect(33025, 'localhost', () => {
-      clearTimeout(timeout);
-      client.destroy();
-      resolve(true);
-    });
-
-    client.on('error', () => {
-      clearTimeout(timeout);
-      resolve(false);
-    });
-  });
-};
-
-describe('StorageConnector Integration Tests @integration', () => {
-  let storage;
-  let minioAvailable = false;
-
-  beforeAll(async () => {
-    minioAvailable = await checkMinIOConnection();
-    if (!minioAvailable) {
-      console.log('\n⚠️  MinIO is not available at localhost:33025');
-      console.log('   Integration tests will be skipped.');
-      console.log('   To run integration tests, start MinIO with:');
-      console.log('   docker-compose up api_shared_storage\n');
-    }
-  });
-
-  beforeEach(() => {
-    if (minioAvailable) {
-      storage = new StorageConnector({
-        endPoint: 'localhost',
-        port: 33025,
-        useSSL: false,
-        accessKey: 'minioadmin',
-        secretKey: 'minioadmin',
-        bucketName: 'test-connector-storage'
-      });
-    }
-  });
-
-  afterEach(async () => {
-    if (minioAvailable && storage && storage.initialized) {
-      // Clean up test objects but keep the bucket
-      try {
-        const objectsStream = storage.minioClient.listObjects(storage.config.bucketName, '', true);
-        const objects = [];
-        objectsStream.on('data', obj => objects.push(obj.name));
-        await new Promise((resolve, reject) => {
-          objectsStream.on('end', resolve);
-          objectsStream.on('error', reject);
-        });
-
-        for (const objectName of objects) {
-          await storage.minioClient.removeObject(storage.config.bucketName, objectName);
-        }
-      } catch (err) {
-        // Ignore cleanup errors
-      }
-    }
-  });
-
-  describe('MinIO Operations', () => {
-    testIf(minioAvailable)('should initialize and create bucket', async () => {
-      await storage.initialize();
-      expect(storage.initialized).toBe(true);
-
-      const bucketExists = await storage.minioClient.bucketExists(storage.config.bucketName);
-      expect(bucketExists).toBe(true);
-    });
-
-    testIf(minioAvailable)('should upload and download with fingerprint verification', async () => {
-      await storage.initialize();
-
-      const content = 'Test content for integration test';
-      const objectName = 'test-file.txt';
-
-      // Upload with fingerprint
-      const uploadResult = await storage.uploadWithFingerprint(objectName, content);
-      expect(uploadResult.fingerprint).toBeDefined();
-      expect(uploadResult.objectName).toContain(uploadResult.fingerprint);
-
-      // Download with verification
-      const downloadResult = await storage.downloadWithVerification(uploadResult.objectName);
-      expect(downloadResult.valid).toBe(true);
-      expect(downloadResult.data.toString()).toBe(content);
-      expect(downloadResult.fingerprint).toBe(uploadResult.fingerprint);
-    });
-
-    testIf(minioAvailable)('should detect fingerprint mismatch', async () => {
-      await storage.initialize();
-
-      const content = 'Original content';
-      const objectName = 'test-file.txt';
-
-      // Upload content
-      const uploadResult = await storage.uploadWithFingerprint(objectName, content);
-
-      // Manually upload different content with same name pattern
-      const differentContent = 'Modified content';
-      const wrongFingerprint = 'wrong123fingerprint456';
-      const tamperedName = storage.getObjectNameWithFingerprint(objectName, wrongFingerprint);
-
-      await storage.minioClient.putObject(
-        storage.config.bucketName,
-        tamperedName,
-        differentContent
-      );
-
-      // Try to download and verify
-      const downloadResult = await storage.downloadWithVerification(tamperedName);
-      expect(downloadResult.valid).toBe(false);
-      expect(downloadResult.error).toContain('mismatch');
-    });
-
-    testIf(minioAvailable)('should handle duplicate uploads (idempotency)', async () => {
-      await storage.initialize();
-
-      const content = 'Duplicate test content';
-      const objectName = 'duplicate-file.txt';
-
-      // Upload twice
-      const result1 = await storage.uploadWithFingerprint(objectName, content);
-      const result2 = await storage.uploadWithFingerprint(objectName, content);
-
-      // Should have same fingerprint
-      expect(result1.fingerprint).toBe(result2.fingerprint);
-      expect(result1.objectName).toBe(result2.objectName);
-    });
-
-    testIf(minioAvailable)('should list objects with fingerprints', async () => {
-      await storage.initialize();
-
-      // Upload multiple files
-      await storage.uploadWithFingerprint('file1.txt', 'Content 1');
-      await storage.uploadWithFingerprint('file2.txt', 'Content 2');
-      await storage.uploadWithFingerprint('file3.txt', 'Content 3');
-
-      // List objects
-      const objects = await storage.listObjectsWithFingerprints();
-      expect(objects.length).toBeGreaterThanOrEqual(3);
-
-      objects.forEach(obj => {
-        expect(obj.name).toBeDefined();
-        expect(obj.fingerprint).toBeDefined();
-        expect(obj.size).toBeDefined();
-        expect(obj.lastModified).toBeDefined();
-      });
-    });
-
-    testIf(minioAvailable)('should generate presigned URL', async () => {
-      await storage.initialize();
-
-      const content = 'Content for presigned URL';
-      const objectName = 'presigned-file.txt';
-
-      // Upload file
-      const uploadResult = await storage.uploadWithFingerprint(objectName, content);
-
-      // Generate presigned URL
-      const url = await storage.getPresignedUrl(uploadResult.objectName, 60);
-      expect(url).toBeDefined();
-      expect(url).toContain('http');
-      expect(url).toContain(uploadResult.objectName);
-    });
-
-    testIf(minioAvailable)('should handle cache correctly', async () => {
-      await storage.initialize();
-
-      const content = 'Cached content';
-      const objectName = 'cached-file.txt';
-
-      // Upload
-      const uploadResult = await storage.uploadWithFingerprint(objectName, content);
-
-      // First download (not cached)
-      const result1 = await storage.downloadWithVerification(uploadResult.objectName);
-      expect(result1.fromCache).toBe(false);
-
-      // Second download (should be cached)
-      const result2 = await storage.downloadWithVerification(uploadResult.objectName);
-      expect(result2.fromCache).toBe(true);
-      expect(result2.data.toString()).toBe(content);
-    });
-  });
-
-  describe('Error Handling', () => {
-    testIf(minioAvailable)('should handle non-existent object', async () => {
-      await storage.initialize();
-
-      await expect(storage.downloadWithVerification('non-existent-file.txt'))
-        .rejects.toThrow();
-    });
-
-    testIf(minioAvailable)('should handle invalid credentials', async () => {
-      const invalidStorage = new StorageConnector({
-        accessKey: 'invalid',
-        secretKey: 'invalid'
-      });
-
-      await expect(invalidStorage.initialize()).rejects.toThrow();
-    });
-  });
-});