@onlineapps/conn-base-storage 1.0.0

package/test/unit/storage.unit.test.js

@@ -0,0 +1,373 @@
+/**
+ * Unit Tests pro StorageConnector
+ * 100% mockované - MUSÍ VŽDY PROJÍT (100% pass rate)
+ * Žádné externí závislosti - vše je mockované
+ *
+ * Testovací strategie:
+ * - Všechny MinIO operace jsou mockovány
+ * - Testy běží bez potřeby MinIO serveru
+ * - Pokrývají všechny metody a edge cases
+ */
+
+const StorageConnector = require('../../src/index');
+const crypto = require('crypto');
+
+// Mock MinIO client kompletně
+jest.mock('minio', () => {
+  return {
+    Client: jest.fn().mockImplementation(() => ({
+      bucketExists: jest.fn(),
+      makeBucket: jest.fn(),
+      setBucketPolicy: jest.fn(),
+      putObject: jest.fn(),
+      getObject: jest.fn(),
+      statObject: jest.fn(),
+      removeObject: jest.fn(),
+      removeBucket: jest.fn(),
+      listObjectsV2: jest.fn(),
+      presignedGetObject: jest.fn(),
+      presignedGetUrl: jest.fn(),
+      useSSL: false,
+      port: 9000,
+      host: 'localhost'
+    }))
+  };
+});
+
+describe('StorageConnector Unit Tests', () => {
+  describe('Initialization', () => {
+    test('should create instance with default config', () => {
+      const storage = new StorageConnector();
+      expect(storage).toBeDefined();
+      expect(storage.config).toBeDefined();
+      expect(storage.config.endPoint).toBe('localhost');
+      expect(storage.config.port).toBe(9000);
+    });
+
+    test('should create instance with custom config', () => {
+      const config = {
+        endPoint: 'minio.example.com',
+        port: 9001,
+        useSSL: true,
+        accessKey: 'custom-key',
+        secretKey: 'custom-secret',
+        bucketName: 'custom-bucket'
+      };
+
+      const storage = new StorageConnector(config);
+      expect(storage.config.endPoint).toBe('minio.example.com');
+      expect(storage.config.port).toBe(9001);
+      expect(storage.config.useSSL).toBe(true);
+      expect(storage.config.bucketName).toBe('custom-bucket');
+    });
+  });
+
+  describe('Fingerprinting', () => {
+    let storage;
+
+    beforeEach(() => {
+      storage = new StorageConnector();
+    });
+
+    test('should generate fingerprint for string content', () => {
+      const content = 'Hello, World!';
+      const fingerprint = storage.generateFingerprint(content);
+
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64); // SHA256 produces 64 hex characters
+      expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    test('should generate consistent fingerprint for same content', () => {
+      const content = 'Test content';
+      const fingerprint1 = storage.generateFingerprint(content);
+      const fingerprint2 = storage.generateFingerprint(content);
+
+      expect(fingerprint1).toBe(fingerprint2);
+    });
+
+    test('should generate different fingerprints for different content', () => {
+      const fingerprint1 = storage.generateFingerprint('Content 1');
+      const fingerprint2 = storage.generateFingerprint('Content 2');
+
+      expect(fingerprint1).not.toBe(fingerprint2);
+    });
+
+    test('should handle Buffer content', () => {
+      const buffer = Buffer.from('Buffer content');
+      const fingerprint = storage.generateFingerprint(buffer);
+
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle object content', () => {
+      const obj = { key: 'value', nested: { data: 123 } };
+      const fingerprint = storage.generateFingerprint(obj);
+
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle array content', () => {
+      const arr = [1, 2, 3, 'test', { key: 'value' }];
+      const fingerprint = storage.generateFingerprint(arr);
+
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle null content', () => {
+      const fingerprint = storage.generateFingerprint(null);
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle undefined content', () => {
+      const fingerprint = storage.generateFingerprint(undefined);
+      expect(fingerprint).toBeDefined();
+      expect(fingerprint).toHaveLength(64);
+    });
+
+    test('should handle circular references in objects', () => {
+      const obj = { name: 'test' };
+      obj.circular = obj;
+
+      expect(() => storage.generateFingerprint(obj)).not.toThrow();
+      const fingerprint = storage.generateFingerprint(obj);
+      expect(fingerprint).toBeDefined();
+    });
+  });
+
+  describe('Cache Management', () => {
+    let storage;
+
+    beforeEach(() => {
+      storage = new StorageConnector({ cacheMaxSize: 3 });
+    });
+
+    test('should add items to cache', () => {
+      storage.addToCache('key1', 'value1');
+      expect(storage.getFromCache('key1')).toBe('value1');
+    });
+
+    test('should maintain insertion order (Map behavior)', () => {
+      storage.addToCache('key1', 'value1');
+      storage.addToCache('key2', 'value2');
+      storage.addToCache('key3', 'value3');
+      storage.addToCache('key4', 'value4');
+
+      // Map maintains insertion order, removes oldest
+      expect(storage.getFromCache('key1')).toBeUndefined();
+      expect(storage.getFromCache('key2')).toBe('value2');
+      expect(storage.getFromCache('key3')).toBe('value3');
+      expect(storage.getFromCache('key4')).toBe('value4');
+    });
+
+    test('should clear cache', () => {
+      storage.addToCache('key1', 'value1');
+      storage.addToCache('key2', 'value2');
+
+      storage.clearCache();
+
+      expect(storage.getFromCache('key1')).toBeUndefined();
+      expect(storage.getFromCache('key2')).toBeUndefined();
+    });
+
+    test('should respect cache max size', () => {
+      for (let i = 0; i < 10; i++) {
+        storage.addToCache(`key${i}`, `value${i}`);
+      }
+
+      // Only last 3 items should be in cache
+      expect(storage.cache.size).toBe(3);
+    });
+  });
+
+  describe('Error Handling', () => {
+    let storage;
+
+    beforeEach(() => {
+      storage = new StorageConnector();
+    });
+
+    test('should handle invalid content types for fingerprinting', () => {
+      const symbol = Symbol('test');
+      expect(() => storage.generateFingerprint(symbol)).not.toThrow();
+    });
+
+    test('should validate bucket name', () => {
+      const validNames = ['valid-bucket', 'bucket123', 'my.bucket'];
+      const invalidNames = ['', 'a', 'UPPERCASE', 'bucket_name', 'bucket-'];
+
+      validNames.forEach(name => {
+        const s = new StorageConnector({ bucketName: name });
+        expect(s.config.bucketName).toBe(name);
+      });
+
+      // Invalid names should use default
+      invalidNames.forEach(name => {
+        const s = new StorageConnector({ bucketName: name });
+        expect(s.config.bucketName).toBe('oa-drive-storage');
+      });
+    });
+  });
+
+  describe('Utility Methods', () => {
+    let storage;
+
+    beforeEach(() => {
+      storage = new StorageConnector();
+    });
+
+    test('should generate object name with fingerprint', () => {
+      const originalName = 'test-file.json';
+      const fingerprint = 'abc123def456';
+
+      const objectName = storage.getObjectNameWithFingerprint(originalName, fingerprint);
+
+      expect(objectName).toContain(fingerprint);
+      expect(objectName).toContain('test-file');
+      expect(objectName).toContain('.json');
+    });
+
+    test('should extract fingerprint from object name', () => {
+      // SHA256 produces 64 character hex string
+      const testFingerprint = 'a'.repeat(64);
+      const objectName = `test-file-${testFingerprint}.json`;
+      const fingerprint = storage.extractFingerprintFromName(objectName);
+
+      expect(fingerprint).toBe(testFingerprint);
+    });
+
+    test('should return null for object name without fingerprint', () => {
+      const objectName = 'regular-file.json';
+      const fingerprint = storage.extractFingerprintFromName(objectName);
+
+      expect(fingerprint).toBeNull();
+    });
+  });
+
+  describe('Mocked MinIO Operations', () => {
+    let storage;
+    let mockClient;
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+      storage = new StorageConnector();
+      mockClient = storage.minioClient;
+    });
+
+    test('should initialize with mocked MinIO client', async () => {
+      mockClient.bucketExists.mockResolvedValue(false);
+      mockClient.makeBucket.mockResolvedValue();
+      mockClient.setBucketPolicy.mockResolvedValue();
+
+      await storage.initialize();
+
+      expect(storage.initialized).toBe(true);
+      expect(mockClient.bucketExists).toHaveBeenCalled();
+      expect(mockClient.makeBucket).toHaveBeenCalled();
+    });
+
+    test('should upload with fingerprint using mocked client', async () => {
+      mockClient.statObject.mockRejectedValue({ code: 'NotFound' });
+      mockClient.putObject.mockResolvedValue();
+
+      const result = await storage.uploadWithFingerprint('test-bucket', 'test content');
+
+      expect(result.fingerprint).toBeDefined();
+      expect(result.existed).toBe(false);
+      expect(mockClient.putObject).toHaveBeenCalled();
+    });
+
+    test('should download with verification using mocked client', async () => {
+      const content = 'test content';
+      const fingerprint = storage.generateFingerprint(content);
+
+      // Mock stream for getObject
+      const mockStream = {
+        [Symbol.asyncIterator]: async function* () {
+          yield Buffer.from(content);
+        }
+      };
+      mockClient.getObject.mockResolvedValue(mockStream);
+
+      const result = await storage.downloadWithVerification(
+        'test-bucket',
+        'test-path',
+        fingerprint
+      );
+
+      expect(result).toBe(content);
+      expect(mockClient.getObject).toHaveBeenCalledWith('test-bucket', 'test-path');
+    });
+
+    test('should list objects with mocked client', async () => {
+      const mockObjects = [
+        { name: 'file1.txt', size: 100, lastModified: new Date() },
+        { name: 'file2.txt', size: 200, lastModified: new Date() }
+      ];
+
+      mockClient.listObjectsV2.mockReturnValue({
+        on: jest.fn((event, callback) => {
+          if (event === 'data') {
+            mockObjects.forEach(callback);
+          } else if (event === 'end') {
+            callback();
+          }
+          return mockClient.listObjectsV2();
+        })
+      });
+
+      const result = await storage.listObjectsWithFingerprints('test-bucket');
+
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('file1.txt');
+    });
+
+    test('should generate presigned URL with mocked client', async () => {
+      const expectedUrl = 'http://localhost:9000/bucket/object?signature=xyz';
+      mockClient.presignedGetUrl.mockResolvedValue(expectedUrl);
+
+      const url = await storage.getPresignedUrl('test-bucket', 'test-object');
+
+      expect(url).toBe(expectedUrl);
+      expect(mockClient.presignedGetUrl).toHaveBeenCalledWith(
+        'GET',
+        'test-bucket',
+        'test-object',
+        86400
+      );
+    });
+
+    test('should handle errors from mocked client', async () => {
+      mockClient.bucketExists.mockRejectedValue(new Error('Connection failed'));
+
+      await expect(storage.initialize()).rejects.toThrow('Connection failed');
+    });
+
+    test('should detect existing objects (idempotency)', async () => {
+      mockClient.statObject.mockResolvedValue({ size: 100, metaData: {} });
+
+      const result = await storage.uploadWithFingerprint('test-bucket', 'content');
+
+      expect(result.existed).toBe(true);
+      expect(mockClient.putObject).not.toHaveBeenCalled();
+    });
+
+    test('should verify fingerprint mismatch', async () => {
+      const wrongContent = 'wrong content';
+      const mockStream = {
+        [Symbol.asyncIterator]: async function* () {
+          yield Buffer.from(wrongContent);
+        }
+      };
+      mockClient.getObject.mockResolvedValue(mockStream);
+
+      await expect(
+        storage.downloadWithVerification('bucket', 'path', 'expectedfingerprint123')
+      ).rejects.toThrow('Fingerprint mismatch');
+    });
+  });
+});