@onlineapps/conn-base-storage 1.0.0

package/test/unit/legacy.storage.test.js.bak

@@ -0,0 +1,614 @@
+const StorageConnector = require('../src/index');
+const crypto = require('crypto');
+
+describe('StorageConnector', () => {
+  let storage;
+
+  beforeEach(() => {
+    storage = new StorageConnector({
+      endPoint: 'localhost',
+      port: 9000,
+      useSSL: false,
+      accessKey: 'minioadmin',
+      secretKey: 'minioadmin',
+      defaultBucket: 'test-bucket',
+      logLevel: 'error' // Quiet during tests
+    });
+  });
+
+  describe('Initialization', () => {
+    test('should create instance with default config', () => {
+      const defaultStorage = new StorageConnector();
+      expect(defaultStorage.defaultBucket).toBe('api-storage');
+      expect(defaultStorage.cacheEnabled).toBe(true);
+      expect(defaultStorage.maxCacheSize).toBe(100);
+    });
+
+    test('should create instance with custom config', () => {
+      const customStorage = new StorageConnector({
+        defaultBucket: 'custom-bucket',
+        cacheEnabled: false,
+        maxCacheSize: 50
+      });
+      expect(customStorage.defaultBucket).toBe('custom-bucket');
+      expect(customStorage.cacheEnabled).toBe(false);
+      expect(customStorage.maxCacheSize).toBe(50);
+    });
+  });
+
+  describe('Fingerprinting', () => {
+    test('should generate consistent fingerprint for same content', () => {
+      const content = { test: 'data', value: 123 };
+
+      const fingerprint1 = storage.generateFingerprint(content);
+      const fingerprint2 = storage.generateFingerprint(content);
+
+      expect(fingerprint1).toBe(fingerprint2);
+      expect(fingerprint1).toHaveLength(64); // SHA256 hex length
+    });
+
+    test('should generate different fingerprints for different content', () => {
+      const content1 = { test: 'data1' };
+      const content2 = { test: 'data2' };
+
+      const fingerprint1 = storage.generateFingerprint(content1);
+      const fingerprint2 = storage.generateFingerprint(content2);
+
+      expect(fingerprint1).not.toBe(fingerprint2);
+    });
+
+    test('should handle string content', () => {
+      const content = 'test string';
+      const fingerprint = storage.generateFingerprint(content);
+
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle buffer content', () => {
+      const content = Buffer.from('test buffer');
+      const fingerprint = storage.generateFingerprint(content);
+
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle JSON objects with consistent ordering', () => {
+      const obj1 = { b: 2, a: 1 };
+      const obj2 = { a: 1, b: 2 };
+
+      const fp1 = storage.generateFingerprint(obj1);
+      const fp2 = storage.generateFingerprint(obj2);
+
+      // JSON.stringify may produce different results for different key orders
+      // This test documents the behavior
+      expect(fp1).toBeDefined();
+      expect(fp2).toBeDefined();
+    });
+
+    test('should handle nested objects', () => {
+      const nested = {
+        level1: {
+          level2: {
+            data: 'test'
+          }
+        }
+      };
+
+      const fingerprint = storage.generateFingerprint(nested);
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle arrays', () => {
+      const array = [1, 2, 3, { test: 'data' }];
+      const fingerprint = storage.generateFingerprint(array);
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+  });
+
+  describe('Cache Management', () => {
+    test('should cache content when enabled', () => {
+      storage.cacheEnabled = true;
+      const key = 'test/path/abc123';
+      const value = 'test content';
+
+      storage.updateCache(key, value);
+
+      expect(storage.contentCache.has(key)).toBe(true);
+      expect(storage.contentCache.get(key)).toBe(value);
+    });
+
+    test('should not cache when disabled', () => {
+      storage.cacheEnabled = false;
+      const key = 'test/path/abc123';
+      const value = 'test content';
+
+      // updateCache should still work but won't be used when cacheEnabled is false
+      storage.updateCache(key, value);
+
+      // Cache is still updated but won't be checked when disabled
+      expect(storage.contentCache.has(key)).toBe(true);
+    });
+
+    test('should evict oldest entry when cache is full', () => {
+      storage.maxCacheSize = 2;
+
+      storage.updateCache('key1', 'value1');
+      storage.updateCache('key2', 'value2');
+      storage.updateCache('key3', 'value3'); // Should evict key1
+
+      expect(storage.contentCache.has('key1')).toBe(false);
+      expect(storage.contentCache.has('key2')).toBe(true);
+      expect(storage.contentCache.has('key3')).toBe(true);
+    });
+
+    test('should maintain insertion order (Map behavior)', () => {
+      storage.maxCacheSize = 3;
+
+      storage.updateCache('key1', 'value1');
+      storage.updateCache('key2', 'value2');
+      storage.updateCache('key3', 'value3');
+
+      // Map maintains insertion order, not LRU
+      // When adding key4, it will evict the first inserted (key1)
+      storage.updateCache('key4', 'value4');
+
+      expect(storage.contentCache.has('key1')).toBe(false); // First inserted, first evicted
+      expect(storage.contentCache.has('key2')).toBe(true);
+      expect(storage.contentCache.has('key3')).toBe(true);
+      expect(storage.contentCache.has('key4')).toBe(true);
+    });
+
+    test('should clear cache', () => {
+      storage.updateCache('key1', 'value1');
+      storage.updateCache('key2', 'value2');
+
+      storage.clearCache();
+
+      expect(storage.contentCache.size).toBe(0);
+    });
+
+    test('should handle large cache sizes', () => {
+      storage.maxCacheSize = 1000;
+
+      for (let i = 0; i < 1000; i++) {
+        storage.updateCache(`key${i}`, `value${i}`);
+      }
+
+      expect(storage.contentCache.size).toBe(1000);
+
+      // Add one more - should evict first
+      storage.updateCache('key1000', 'value1000');
+      expect(storage.contentCache.size).toBe(1000);
+      expect(storage.contentCache.has('key0')).toBe(false);
+      expect(storage.contentCache.has('key1000')).toBe(true);
+    });
+  });
+
+  describe('Internal URL Generation', () => {
+    test('should generate abstract internal URL', () => {
+      const url = storage.getInternalUrl('my-bucket', 'path/to/file.json');
+      expect(url).toBe('internal://storage/my-bucket/path/to/file.json');
+    });
+
+    test('should generate internal URL for different buckets', () => {
+      const url1 = storage.getInternalUrl('bucket1', 'file1.json');
+      const url2 = storage.getInternalUrl('bucket2', 'file2.json');
+
+      expect(url1).toBe('internal://storage/bucket1/file1.json');
+      expect(url2).toBe('internal://storage/bucket2/file2.json');
+    });
+
+    test('should handle complex paths', () => {
+      const url = storage.getInternalUrl('my-bucket', 'deep/nested/path/to/file.json');
+      expect(url).toBe('internal://storage/my-bucket/deep/nested/path/to/file.json');
+    });
+
+    test('should handle special characters in path', () => {
+      const url = storage.getInternalUrl('my-bucket', 'path/to/file with spaces.json');
+      expect(url).toBe('internal://storage/my-bucket/path/to/file with spaces.json');
+    });
+
+    test('getPublicUrl should return internal URL for backward compatibility', () => {
+      const url = storage.getPublicUrl('my-bucket', 'file.json');
+      expect(url).toBe('internal://storage/my-bucket/file.json');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should handle invalid content types for fingerprinting', () => {
+      const invalidContent = undefined;
+
+      // Should convert to string
+      expect(() => storage.generateFingerprint(invalidContent)).not.toThrow();
+    });
+
+    test('should handle null content', () => {
+      const nullContent = null;
+
+      // Should convert to string
+      expect(() => storage.generateFingerprint(nullContent)).not.toThrow();
+    });
+
+    test('should handle circular references in objects', () => {
+      const obj = { a: 1 };
+      obj.circular = obj;
+
+      // Should handle circular reference gracefully
+      expect(() => storage.generateFingerprint(obj)).not.toThrow();
+
+      // Should produce consistent fingerprint for circular references
+      const fingerprint = storage.generateFingerprint(obj);
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+  });
+});
+
+// Mock MinIO client for unit tests
+describe('StorageConnector Mock Tests', () => {
+  let storage;
+  let mockClient;
+
+  beforeEach(() => {
+    storage = new StorageConnector({
+      defaultBucket: 'test-bucket',
+      logLevel: 'error'
+    });
+
+    // Mock MinIO client methods
+    mockClient = {
+      bucketExists: jest.fn(),
+      makeBucket: jest.fn(),
+      setBucketPolicy: jest.fn(),
+      putObject: jest.fn(),
+      getObject: jest.fn(),
+      statObject: jest.fn(),
+      removeObject: jest.fn(),
+      listObjectsV2: jest.fn(),
+      presignedGetObject: jest.fn()
+    };
+
+    storage.client = mockClient;
+  });
+
+  describe('initialize', () => {
+    test('should create bucket if it does not exist', async () => {
+      mockClient.bucketExists.mockResolvedValue(false);
+      mockClient.makeBucket.mockResolvedValue();
+      mockClient.setBucketPolicy.mockResolvedValue();
+
+      const result = await storage.initialize();
+
+      expect(result).toBe(true);
+      expect(mockClient.bucketExists).toHaveBeenCalledWith('test-bucket');
+      expect(mockClient.makeBucket).toHaveBeenCalledWith('test-bucket', 'us-east-1');
+      expect(mockClient.setBucketPolicy).toHaveBeenCalled();
+    });
+
+    test('should not create bucket if it exists', async () => {
+      mockClient.bucketExists.mockResolvedValue(true);
+
+      const result = await storage.initialize();
+
+      expect(result).toBe(true);
+      expect(mockClient.bucketExists).toHaveBeenCalledWith('test-bucket');
+      expect(mockClient.makeBucket).not.toHaveBeenCalled();
+    });
+
+    test('should handle initialization errors', async () => {
+      mockClient.bucketExists.mockRejectedValue(new Error('Connection failed'));
+
+      await expect(storage.initialize()).rejects.toThrow('Connection failed');
+    });
+  });
+
+  describe('uploadWithFingerprint', () => {
+    test('should upload new content with fingerprint', async () => {
+      const content = { test: 'data' };
+      const fingerprint = storage.generateFingerprint(content);
+
+      mockClient.statObject.mockRejectedValue(new Error('Not found'));
+      mockClient.putObject.mockResolvedValue();
+
+      const result = await storage.uploadWithFingerprint('test-bucket', content, 'test/path');
+
+      expect(result).toMatchObject({
+        fingerprint,
+        bucket: 'test-bucket',
+        path: `test/path/${fingerprint}.json`,
+        existed: false
+      });
+
+      expect(mockClient.putObject).toHaveBeenCalled();
+    });
+
+    test('should skip upload if content already exists', async () => {
+      const content = { test: 'data' };
+      const fingerprint = storage.generateFingerprint(content);
+
+      mockClient.statObject.mockResolvedValue({ size: 100 });
+
+      const result = await storage.uploadWithFingerprint('test-bucket', content, 'test/path');
+
+      expect(result).toMatchObject({
+        fingerprint,
+        bucket: 'test-bucket',
+        path: `test/path/${fingerprint}.json`,
+        existed: true
+      });
+
+      expect(mockClient.putObject).not.toHaveBeenCalled();
+    });
+
+    test('should handle upload without path prefix', async () => {
+      const content = 'simple string';
+      const fingerprint = storage.generateFingerprint(content);
+
+      mockClient.statObject.mockRejectedValue(new Error('Not found'));
+      mockClient.putObject.mockResolvedValue();
+
+      const result = await storage.uploadWithFingerprint('test-bucket', content);
+
+      expect(result.path).toBe(`${fingerprint}.json`);
+    });
+
+    test('should use default bucket if not specified', async () => {
+      const content = { test: 'data' };
+
+      mockClient.statObject.mockRejectedValue(new Error('Not found'));
+      mockClient.putObject.mockResolvedValue();
+
+      const result = await storage.uploadWithFingerprint(null, content);
+
+      expect(result.bucket).toBe('test-bucket');
+    });
+  });
+
+  describe('ensureBucket', () => {
+    test('should create bucket if not exists', async () => {
+      mockClient.bucketExists.mockResolvedValue(false);
+      mockClient.makeBucket.mockResolvedValue();
+
+      const result = await storage.ensureBucket('new-bucket');
+
+      expect(result).toBe(true);
+      expect(mockClient.makeBucket).toHaveBeenCalledWith('new-bucket', 'us-east-1');
+    });
+
+    test('should not create bucket if exists', async () => {
+      mockClient.bucketExists.mockResolvedValue(true);
+
+      const result = await storage.ensureBucket('existing-bucket');
+
+      expect(result).toBe(true);
+      expect(mockClient.makeBucket).not.toHaveBeenCalled();
+    });
+
+    test('should handle errors', async () => {
+      mockClient.bucketExists.mockRejectedValue(new Error('Network error'));
+
+      await expect(storage.ensureBucket('error-bucket')).rejects.toThrow('Network error');
+    });
+  });
+});
+
+// Integration tests (require actual MinIO)
+// 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(9000, 'localhost', () => {
+      clearTimeout(timeout);
+      client.destroy();
+      resolve(true);
+    });
+
+    client.on('error', () => {
+      clearTimeout(timeout);
+      resolve(false);
+    });
+  });
+};
+
+describe('StorageConnector Integration', () => {
+  let storage;
+  let minioAvailable = false;
+
+  beforeAll(async () => {
+    minioAvailable = await checkMinIOConnection();
+
+    if (!minioAvailable) {
+      console.log('⚠️  MinIO is not available - integration tests will be skipped');
+      return;
+    }
+
+    storage = new StorageConnector({
+      endPoint: process.env.MINIO_ENDPOINT || 'localhost',
+      port: parseInt(process.env.MINIO_PORT || 9000),
+      useSSL: process.env.MINIO_USE_SSL === 'true',
+      accessKey: process.env.MINIO_ACCESS_KEY || 'minioadmin',
+      secretKey: process.env.MINIO_SECRET_KEY || 'minioadmin',
+      defaultBucket: 'test-integration',
+      logLevel: 'error'
+    });
+
+    try {
+      await storage.initialize();
+    } catch (error) {
+      minioAvailable = false;
+      console.log('MinIO initialization failed - integration tests will be skipped');
+    }
+  });
+
+  testIf(minioAvailable)('should upload and download with fingerprint verification', async () => {
+    const content = {
+      service: 'test-service',
+      version: '1.0.0',
+      timestamp: new Date().toISOString()
+    };
+
+    // Upload
+    const uploadResult = await storage.uploadWithFingerprint(
+      'test-integration',
+      content,
+      'test/specs'
+    );
+
+    expect(uploadResult.fingerprint).toBeDefined();
+    expect(uploadResult.path).toContain(uploadResult.fingerprint);
+
+    // Download with verification
+    const downloaded = await storage.downloadWithVerification(
+      uploadResult.bucket,
+      uploadResult.path,
+      uploadResult.fingerprint
+    );
+
+    const parsed = JSON.parse(downloaded);
+    expect(parsed).toEqual(content);
+  });
+
+  testIf(minioAvailable)('should detect fingerprint mismatch', async () => {
+    const content = { test: 'data' };
+
+    const uploadResult = await storage.uploadWithFingerprint(
+      'test-integration',
+      content,
+      'test/verify'
+    );
+
+    // Try to download with wrong fingerprint
+    await expect(
+      storage.downloadWithVerification(
+        uploadResult.bucket,
+        uploadResult.path,
+        'wrong-fingerprint'
+      )
+    ).rejects.toThrow('Fingerprint mismatch');
+  });
+
+  testIf(minioAvailable)('should handle duplicate uploads (idempotency)', async () => {
+    const content = { test: 'duplicate', timestamp: 123 };
+
+    // First upload
+    const result1 = await storage.uploadWithFingerprint(
+      'test-integration',
+      content,
+      'test/duplicate'
+    );
+
+    expect(result1.existed).toBe(false);
+
+    // Second upload with same content
+    const result2 = await storage.uploadWithFingerprint(
+      'test-integration',
+      content,
+      'test/duplicate'
+    );
+
+    expect(result2.existed).toBe(true);
+    expect(result2.fingerprint).toBe(result1.fingerprint);
+    expect(result2.path).toBe(result1.path);
+  });
+
+  testIf(minioAvailable)('should list objects with fingerprints', async () => {
+    // Upload test objects
+    await storage.uploadWithFingerprint(
+      'test-integration',
+      { test: 'list1' },
+      'test/list'
+    );
+
+    await storage.uploadWithFingerprint(
+      'test-integration',
+      { test: 'list2' },
+      'test/list'
+    );
+
+    // List objects
+    const objects = await storage.listWithFingerprints('test-integration', 'test/list/');
+
+    expect(objects).toBeInstanceOf(Array);
+    expect(objects.length).toBeGreaterThanOrEqual(2);
+
+    objects.forEach(obj => {
+      expect(obj).toHaveProperty('name');
+      expect(obj).toHaveProperty('fingerprint');
+      expect(obj).toHaveProperty('uploadedAt');
+    });
+  });
+
+  testIf(minioAvailable)('should generate presigned URL', async () => {
+    const content = { test: 'presigned' };
+
+    const uploadResult = await storage.uploadWithFingerprint(
+      'test-integration',
+      content,
+      'test/presigned'
+    );
+
+    const url = await storage.getPresignedUrl(
+      uploadResult.bucket,
+      uploadResult.path,
+      300 // 5 minutes
+    );
+
+    expect(url).toContain('X-Amz-Algorithm');
+    expect(url).toContain('X-Amz-Expires');
+  });
+
+  testIf(minioAvailable)('should handle cache correctly', async () => {
+    storage.clearCache(); // Start fresh
+
+    const content = { test: 'cache-test' };
+    const uploadResult = await storage.uploadWithFingerprint(
+      'test-integration',
+      content,
+      'test/cache'
+    );
+
+    // First download - should not be cached
+    const download1 = await storage.downloadWithVerification(
+      uploadResult.bucket,
+      uploadResult.path,
+      uploadResult.fingerprint
+    );
+
+    // Cache should now contain the content
+    const cacheKey = `${uploadResult.bucket}/${uploadResult.path}/${uploadResult.fingerprint}`;
+    expect(storage.contentCache.has(cacheKey)).toBe(true);
+
+    // Second download - should use cache
+    const download2 = await storage.downloadWithVerification(
+      uploadResult.bucket,
+      uploadResult.path,
+      uploadResult.fingerprint
+    );
+
+    expect(download1).toBe(download2);
+  });
+
+  afterAll(async () => {
+    // Cleanup test bucket
+    try {
+      const objects = await storage.listWithFingerprints('test-integration', 'test/');
+      for (const obj of objects) {
+        await storage.deleteObject('test-integration', obj.name);
+      }
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+});