initial commit

Signed-off-by: ale <ale@manalejandro.com>

tests/cache-manager.test.js

@@ -0,0 +1,129 @@
+const CacheManager = require('../src/cache/cache-manager');
+const path = require('path');
+const fs = require('fs-extra');
+
+describe('CacheManager', () => {
+  let cacheManager;
+  let testCacheDir;
+
+  beforeEach(async () => {
+    testCacheDir = path.join(global.TEST_DIR, 'cache');
+    cacheManager = new CacheManager();
+    cacheManager.cacheDir = testCacheDir;
+    cacheManager.metadataFile = path.join(testCacheDir, 'metadata.json');
+    await cacheManager.init();
+  });
+
+  describe('init', () => {
+    test('should create cache directory', async () => {
+      expect(await fs.pathExists(testCacheDir)).toBe(true);
+    });
+
+    test('should create metadata file', async () => {
+      expect(await fs.pathExists(cacheManager.metadataFile)).toBe(true);
+    });
+  });
+
+  describe('store and get', () => {
+    test('should store and retrieve package data', async () => {
+      const packageName = 'test-package';
+      const version = '1.0.0';
+      const data = Buffer.from('test package data');
+
+      await cacheManager.store(packageName, version, data);
+      const retrieved = await cacheManager.get(packageName, version);
+
+      expect(retrieved).toEqual(data);
+    });
+
+    test('should return null for non-existent package', async () => {
+      const retrieved = await cacheManager.get('non-existent', '1.0.0');
+      expect(retrieved).toBeNull();
+    });
+
+    test('should handle binary data correctly', async () => {
+      const packageName = 'binary-package';
+      const version = '1.0.0';
+      const binaryData = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
+
+      await cacheManager.store(packageName, version, binaryData);
+      const retrieved = await cacheManager.get(packageName, version);
+
+      expect(retrieved).toEqual(binaryData);
+    });
+  });
+
+  describe('remove', () => {
+    test('should remove package from cache', async () => {
+      const packageName = 'test-package';
+      const version = '1.0.0';
+      const data = Buffer.from('test data');
+
+      await cacheManager.store(packageName, version, data);
+      expect(await cacheManager.get(packageName, version)).toEqual(data);
+
+      const removed = await cacheManager.remove(packageName, version);
+      expect(removed).toBe(true);
+      expect(await cacheManager.get(packageName, version)).toBeNull();
+    });
+
+    test('should return false for non-existent package', async () => {
+      const removed = await cacheManager.remove('non-existent', '1.0.0');
+      expect(removed).toBe(false);
+    });
+  });
+
+  describe('verify', () => {
+    test('should verify cache integrity', async () => {
+      const packageName = 'test-package';
+      const version = '1.0.0';
+      const data = Buffer.from('test data');
+
+      await cacheManager.store(packageName, version, data);
+      const result = await cacheManager.verify();
+
+      expect(result.corrupted).toBe(0);
+      expect(result.missing).toBe(0);
+      expect(result.valid).toBe(1);
+    });
+  });
+
+  describe('clean', () => {
+    test('should clean entire cache', async () => {
+      const packageName = 'test-package';
+      const version = '1.0.0';
+      const data = Buffer.from('test data');
+
+      await cacheManager.store(packageName, version, data);
+      expect(await cacheManager.get(packageName, version)).toEqual(data);
+
+      const cleanedSize = await cacheManager.clean();
+      expect(cleanedSize).toBeGreaterThan(0);
+      expect(await cacheManager.get(packageName, version)).toBeNull();
+    });
+  });
+
+  describe('getStats', () => {
+    test('should return cache statistics', async () => {
+      const stats = await cacheManager.getStats();
+
+      expect(stats).toHaveProperty('totalEntries');
+      expect(stats).toHaveProperty('totalSize');
+      expect(stats).toHaveProperty('compressionRatio');
+      expect(typeof stats.totalEntries).toBe('number');
+      expect(typeof stats.totalSize).toBe('number');
+    });
+
+    test('should calculate compression ratio correctly', async () => {
+      const packageName = 'test-package';
+      const version = '1.0.0';
+      const data = Buffer.from('test data '.repeat(100)); // Repeatable data for good compression
+
+      await cacheManager.store(packageName, version, data);
+      const stats = await cacheManager.getStats();
+
+      expect(stats.totalEntries).toBe(1);
+      expect(stats.compressionRatio).toBeLessThan(1); // Should be compressed
+    });
+  });
+});