@onlineapps/conn-base-storage 1.0.6 → 1.0.7

package/tests/unit/storage.extended.unit.test.js

@@ -1,444 +0,0 @@
-/**
- * Extended Unit Tests for StorageConnector
- * Focus on increasing coverage with mocked MinIO client
- */
-
-const StorageConnector = require('../../src/index');
-const Minio = require('minio');
-
-// Minimal required MinIO config for tests (all external I/O is mocked)
-const MINIO_CONFIG = {
-  endPoint: 'localhost',
-  port: 9000,
-  accessKey: 'test',
-  secretKey: 'test',
-};
-
-// Mock MinIO client
-jest.mock('minio');
-
-describe('StorageConnector Extended Unit Tests @unit', () => {
-  let storage;
-  let mockMinioClient;
-
-  beforeEach(() => {
-    // Setup mock MinIO client
-    mockMinioClient = {
-      bucketExists: jest.fn(),
-      makeBucket: jest.fn(),
-      setBucketPolicy: jest.fn(),
-      putObject: jest.fn(),
-      getObject: jest.fn(),
-      statObject: jest.fn(),
-      listObjectsV2: jest.fn(),
-      presignedGetUrl: jest.fn(),
-      presignedUrl: jest.fn(), // Add missing mock method
-      removeBucket: jest.fn()
-    };
-
-    Minio.Client.mockImplementation(() => mockMinioClient);
-
-    storage = new StorageConnector({
-      endPoint: 'localhost',
-      port: 9000,
-      accessKey: 'test',
-      secretKey: 'test'
-    });
-  });
-
-  describe('Initialization with Mocked MinIO', () => {
-    test('should initialize and create bucket if not exists', async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(false);
-      mockMinioClient.makeBucket.mockResolvedValue();
-      mockMinioClient.setBucketPolicy.mockResolvedValue();
-
-      await storage.initialize();
-
-      expect(mockMinioClient.bucketExists).toHaveBeenCalledWith('api-storage');
-      expect(mockMinioClient.makeBucket).toHaveBeenCalledWith('api-storage', 'us-east-1');
-      expect(mockMinioClient.setBucketPolicy).toHaveBeenCalled();
-      expect(storage.initialized).toBe(true);
-    });
-
-    test('should not create bucket if already exists', async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(true);
-
-      await storage.initialize();
-
-      expect(mockMinioClient.bucketExists).toHaveBeenCalled();
-      expect(mockMinioClient.makeBucket).not.toHaveBeenCalled();
-      expect(storage.initialized).toBe(true);
-    });
-
-    test('should handle initialization errors', async () => {
-      mockMinioClient.bucketExists.mockRejectedValue(new Error('Connection failed'));
-
-      await expect(storage.initialize()).rejects.toThrow('Connection failed');
-      expect(storage.initialized).toBe(false);
-    });
-  });
-
-  describe('Upload Operations', () => {
-    beforeEach(async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(true);
-      await storage.initialize();
-    });
-
-    test('should upload content with fingerprint', async () => {
-      const content = 'Test content';
-      mockMinioClient.statObject.mockRejectedValue({ code: 'NotFound' });
-      mockMinioClient.putObject.mockResolvedValue({ etag: '123' });
-
-      const result = await storage.uploadWithFingerprint('test-bucket', content, 'prefix');
-
-      expect(result.fingerprint).toHaveLength(64);
-      expect(result.bucket).toBe('test-bucket');
-      expect(result.path).toContain('prefix');
-      expect(result.existed).toBe(false);
-      expect(mockMinioClient.putObject).toHaveBeenCalled();
-    });
-
-    test('should skip upload if object already exists', async () => {
-      const content = 'Existing content';
-      mockMinioClient.statObject.mockResolvedValue({ size: 100 });
-
-      const result = await storage.uploadWithFingerprint('test-bucket', content);
-
-      expect(result.existed).toBe(true);
-      expect(mockMinioClient.putObject).not.toHaveBeenCalled();
-    });
-
-    test('should handle different content types', async () => {
-      mockMinioClient.statObject.mockRejectedValue({ code: 'NotFound' });
-      mockMinioClient.putObject.mockResolvedValue({ etag: '123' });
-
-      // Test with object
-      const objectContent = { key: 'value', nested: { data: 123 } };
-      const result1 = await storage.uploadWithFingerprint('bucket', objectContent);
-      expect(result1.fingerprint).toHaveLength(64);
-
-      // Test with Buffer
-      const bufferContent = Buffer.from('Buffer content');
-      const result2 = await storage.uploadWithFingerprint('bucket', bufferContent);
-      expect(result2.fingerprint).toHaveLength(64);
-
-      // Test with string
-      const stringContent = 'String content';
-      const result3 = await storage.uploadWithFingerprint('bucket', stringContent);
-      expect(result3.fingerprint).toHaveLength(64);
-    });
-
-    test('should use default bucket if not provided', async () => {
-      mockMinioClient.statObject.mockRejectedValue({ code: 'NotFound' });
-      mockMinioClient.putObject.mockResolvedValue({ etag: '123' });
-
-      const result = await storage.uploadWithFingerprint(null, 'content');
-
-      expect(result.bucket).toBe('api-storage');
-      expect(mockMinioClient.putObject).toHaveBeenCalledWith(
-        'api-storage',
-        expect.any(String),
-        expect.any(Buffer),
-        expect.any(Number),
-        expect.any(Object)
-      );
-    });
-
-    test('should handle upload errors', async () => {
-      mockMinioClient.statObject.mockRejectedValue({ code: 'NotFound' });
-      mockMinioClient.putObject.mockRejectedValue(new Error('Upload failed'));
-
-      await expect(storage.uploadWithFingerprint('bucket', 'content'))
-        .rejects.toThrow('Upload failed');
-    });
-  });
-
-  describe('Download Operations', () => {
-    beforeEach(async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(true);
-      await storage.initialize();
-    });
-
-    test('should download and verify content', async () => {
-      const content = 'Downloaded content';
-      const expectedFingerprint = storage.generateFingerprint(content);
-
-      // Mock async iterable stream for getObject
-      const mockStream = {
-        [Symbol.asyncIterator]: async function* () {
-          yield Buffer.from(content);
-        }
-      };
-
-      mockMinioClient.getObject.mockResolvedValue(mockStream);
-
-      const result = await storage.downloadWithVerification(
-        'test-bucket',
-        'test-path',
-        expectedFingerprint
-      );
-
-      expect(result).toBe(content);
-    });
-
-    test('should detect fingerprint mismatch', async () => {
-      const content = 'Content';
-      const wrongFingerprint = 'wrong'.repeat(16); // 64 chars
-
-      const mockStream = {
-        [Symbol.asyncIterator]: async function* () {
-          yield Buffer.from(content);
-        }
-      };
-
-      mockMinioClient.getObject.mockResolvedValue(mockStream);
-
-      await expect(storage.downloadWithVerification(
-        'test-bucket',
-        'test-path',
-        wrongFingerprint
-      )).rejects.toThrow('Fingerprint mismatch');
-    });
-
-    test('should return cached content if available', async () => {
-      const content = 'Cached content';
-      const fingerprint = storage.generateFingerprint(content);
-      const cacheKey = `test-bucket/test-path/${fingerprint}`;
-
-      // Add to cache
-      storage.contentCache.set(cacheKey, content);
-
-      const result = await storage.downloadWithVerification(
-        'test-bucket',
-        'test-path',
-        fingerprint
-      );
-
-      expect(result).toBe(content);
-      expect(mockMinioClient.getObject).not.toHaveBeenCalled();
-    });
-
-    test('should handle download errors', async () => {
-      mockMinioClient.getObject.mockRejectedValue(new Error('Download failed'));
-
-      await expect(storage.downloadWithVerification('bucket', 'path', 'fingerprint'))
-        .rejects.toThrow('Download failed');
-    });
-  });
-
-  describe('List Operations', () => {
-    beforeEach(async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(true);
-      await storage.initialize();
-    });
-
-    test('should list objects with fingerprints', async () => {
-      const mockObjects = [
-        { name: 'file1-abc123.json', size: 100, lastModified: new Date() },
-        { name: 'file2-def456.json', size: 200, lastModified: new Date() }
-      ];
-
-      const mockStream = {
-        on: jest.fn((event, callback) => {
-          if (event === 'data') {
-            mockObjects.forEach(obj => callback(obj));
-          } else if (event === 'end') {
-            setTimeout(callback, 0);
-          }
-          return mockStream;
-        })
-      };
-
-      mockMinioClient.listObjectsV2.mockReturnValue(mockStream);
-
-      const result = await storage.listObjectsWithFingerprints('test-bucket', 'prefix');
-
-      expect(result).toHaveLength(2);
-      expect(result[0].name).toBe('file1-abc123.json');
-      expect(result[0].fingerprint).toBeDefined();
-    });
-
-    test('should handle empty bucket', async () => {
-      const mockStream = {
-        on: jest.fn((event, callback) => {
-          if (event === 'end') {
-            setTimeout(callback, 0);
-          }
-          return mockStream;
-        })
-      };
-
-      mockMinioClient.listObjectsV2.mockReturnValue(mockStream);
-
-      const result = await storage.listObjectsWithFingerprints('test-bucket');
-
-      expect(result).toEqual([]);
-    });
-
-    test('should handle list errors', async () => {
-      const mockStream = {
-        on: jest.fn((event, callback) => {
-          if (event === 'error') {
-            callback(new Error('List failed'));
-          }
-          return mockStream;
-        })
-      };
-
-      mockMinioClient.listObjectsV2.mockReturnValue(mockStream);
-
-      await expect(storage.listObjectsWithFingerprints('test-bucket'))
-        .rejects.toThrow('List failed');
-    });
-  });
-
-  describe('Presigned URLs', () => {
-    beforeEach(async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(true);
-      await storage.initialize();
-    });
-
-    test('should generate presigned URL', async () => {
-      const mockUrl = 'https://minio.example.com/bucket/object?signature=xyz';
-      mockMinioClient.presignedUrl.mockResolvedValue(mockUrl);
-
-      const url = await storage.getPresignedUrl('test-bucket', 'test-object', 3600);
-
-      expect(url).toBe(mockUrl);
-      expect(mockMinioClient.presignedUrl).toHaveBeenCalledWith(
-        'GET',
-        'test-bucket',
-        'test-object',
-        3600
-      );
-    });
-
-    test('should use default expiry', async () => {
-      mockMinioClient.presignedUrl.mockResolvedValue('https://example.com');
-
-      await storage.getPresignedUrl('bucket', 'object');
-
-      expect(mockMinioClient.presignedUrl).toHaveBeenCalledWith(
-        'GET',
-        'bucket',
-        'object',
-        86400 // Default 24 hours
-      );
-    });
-  });
-
-  describe('Internal URL Generation', () => {
-    test('should generate abstract internal URL', () => {
-      storage = new StorageConnector(MINIO_CONFIG);
-
-      const url = storage.getInternalUrl('bucket', 'path/to/object');
-      expect(url).toBe('internal://storage/bucket/path/to/object');
-    });
-
-    test('should generate consistent internal URLs', () => {
-      const storage1 = new StorageConnector(MINIO_CONFIG);
-      const storage2 = new StorageConnector(MINIO_CONFIG);
-
-      const url1 = storage1.getInternalUrl('bucket', 'object');
-      const url2 = storage2.getInternalUrl('bucket', 'object');
-
-      expect(url1).toBe(url2);
-      expect(url1).toBe('internal://storage/bucket/object');
-    });
-  });
-
-  describe('Bucket Operations', () => {
-    beforeEach(() => {
-      storage = new StorageConnector(MINIO_CONFIG);
-    });
-
-    test('should ensure bucket exists', async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(false);
-      mockMinioClient.makeBucket.mockResolvedValue();
-
-      const result = await storage.ensureBucket('new-bucket');
-
-      expect(result).toBe(true);
-      expect(mockMinioClient.makeBucket).toHaveBeenCalledWith('new-bucket', 'us-east-1');
-    });
-
-    test('should not create bucket if exists', async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(true);
-
-      const result = await storage.ensureBucket('existing-bucket');
-
-      expect(result).toBe(true);
-      expect(mockMinioClient.makeBucket).not.toHaveBeenCalled();
-    });
-
-    test('should handle bucket creation errors', async () => {
-      mockMinioClient.bucketExists.mockResolvedValue(false);
-      mockMinioClient.makeBucket.mockRejectedValue(new Error('Permission denied'));
-
-      await expect(storage.ensureBucket('bucket')).rejects.toThrow('Permission denied');
-    });
-  });
-
-  describe('Cache Operations', () => {
-    test('should clear all caches', () => {
-      storage = new StorageConnector(MINIO_CONFIG);
-
-      // Add items to caches
-      storage.cache.set('key1', 'value1');
-      storage.contentCache.set('key2', 'value2');
-
-      expect(storage.cache.size).toBe(1);
-      expect(storage.contentCache.size).toBe(1);
-
-      storage.clearCache();
-
-      expect(storage.cache.size).toBe(0);
-      expect(storage.contentCache.size).toBe(0);
-    });
-
-    test('should handle cache size limits', () => {
-      storage = new StorageConnector({ ...MINIO_CONFIG, cacheMaxSize: 2 });
-
-      storage.addToCache('key1', 'value1');
-      storage.addToCache('key2', 'value2');
-      storage.addToCache('key3', 'value3');
-
-      expect(storage.cache.size).toBe(2);
-      expect(storage.getFromCache('key1')).toBeUndefined();
-      expect(storage.getFromCache('key2')).toBe('value2');
-      expect(storage.getFromCache('key3')).toBe('value3');
-    });
-  });
-
-  describe('Error Scenarios', () => {
-    test('should handle network errors', async () => {
-      const networkError = new Error('ECONNREFUSED');
-      networkError.code = 'ECONNREFUSED';
-
-      mockMinioClient.bucketExists.mockRejectedValue(networkError);
-
-      await expect(storage.initialize()).rejects.toThrow('ECONNREFUSED');
-    });
-
-    test('should handle invalid credentials', async () => {
-      const authError = new Error('InvalidAccessKeyId');
-      authError.code = 'InvalidAccessKeyId';
-
-      mockMinioClient.bucketExists.mockRejectedValue(authError);
-
-      await expect(storage.initialize()).rejects.toThrow('InvalidAccessKeyId');
-    });
-
-    test('should handle timeout errors', async () => {
-      const timeoutError = new Error('RequestTimeout');
-      timeoutError.code = 'RequestTimeout';
-
-      mockMinioClient.putObject.mockRejectedValue(timeoutError);
-      mockMinioClient.statObject.mockRejectedValue({ code: 'NotFound' });
-
-      await storage.initialize();
-      await expect(storage.uploadWithFingerprint('bucket', 'content'))
-        .rejects.toThrow('RequestTimeout');
-    });
-  });
-});