@deimoscloud/coreai 0.1.0

package/src/cache/provider.test.ts

@@ -0,0 +1,485 @@
+/**
+ * File Cache Provider Tests
+ */
+
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { FileCacheProvider, createFileCacheProvider } from './provider.js';
+import { CacheError, CACHE_PATHS } from './types.js';
+import type { CacheMetadata } from './types.js';
+
+describe('FileCacheProvider', () => {
+  let testDir: string;
+  let provider: FileCacheProvider;
+
+  beforeEach(async () => {
+    // Create a unique temp directory for each test
+    testDir = join(tmpdir(), `cache-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.mkdir(testDir, { recursive: true });
+
+    provider = new FileCacheProvider({
+      basePath: testDir,
+      ttl: 3600,
+    });
+  });
+
+  afterEach(async () => {
+    // Clean up test directory
+    try {
+      await fs.rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('initialization', () => {
+    it('should not be initialized by default', () => {
+      expect(provider.isInitialized()).toBe(false);
+    });
+
+    it('should initialize successfully', async () => {
+      await provider.initialize();
+      expect(provider.isInitialized()).toBe(true);
+    });
+
+    it('should create cache directories on initialize', async () => {
+      await provider.initialize();
+
+      const contentPath = join(testDir, CACHE_PATHS.CONTENT);
+      const metadataPath = join(testDir, CACHE_PATHS.METADATA);
+
+      const contentStat = await fs.stat(contentPath);
+      const metadataStat = await fs.stat(metadataPath);
+
+      expect(contentStat.isDirectory()).toBe(true);
+      expect(metadataStat.isDirectory()).toBe(true);
+    });
+
+    it('should create index file on initialize', async () => {
+      await provider.initialize();
+
+      const indexPath = join(testDir, CACHE_PATHS.INDEX);
+      const indexContent = await fs.readFile(indexPath, 'utf-8');
+      const index = JSON.parse(indexContent);
+
+      expect(index.version).toBe(1);
+      expect(index.entries).toEqual({});
+    });
+
+    it('should be idempotent', async () => {
+      await provider.initialize();
+      await provider.initialize();
+      expect(provider.isInitialized()).toBe(true);
+    });
+  });
+
+  describe('operations without initialization', () => {
+    it('should throw on get without initialization', async () => {
+      await expect(provider.get('key')).rejects.toThrow(CacheError);
+    });
+
+    it('should throw on set without initialization', async () => {
+      await expect(provider.set('key', 'content', {})).rejects.toThrow(CacheError);
+    });
+
+    it('should throw on has without initialization', async () => {
+      await expect(provider.has('key')).rejects.toThrow(CacheError);
+    });
+
+    it('should throw on delete without initialization', async () => {
+      await expect(provider.delete('key')).rejects.toThrow(CacheError);
+    });
+  });
+
+  describe('set and get', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should set and get string content', async () => {
+      await provider.set('test-key', 'Hello, World!', {
+        source: 'local',
+        sourceUrl: '/test/path',
+      });
+
+      const entry = await provider.get('test-key');
+
+      expect(entry).not.toBeNull();
+      expect(entry?.content).toBe('Hello, World!');
+      expect(entry?.metadata.key).toBe('test-key');
+      expect(entry?.metadata.source).toBe('local');
+    });
+
+    it('should set and get object content', async () => {
+      const data = { name: 'Test', value: 42 };
+
+      await provider.set('object-key', data, {
+        source: 'github',
+        sourceUrl: 'https://github.com/owner/repo',
+        contentType: 'application/json',
+      });
+
+      const entry = await provider.get<typeof data>('object-key');
+
+      expect(entry).not.toBeNull();
+      expect(entry?.content).toEqual(data);
+    });
+
+    it('should return null for non-existent key', async () => {
+      const entry = await provider.get('non-existent');
+      expect(entry).toBeNull();
+    });
+
+    it('should update existing entry', async () => {
+      await provider.set('update-key', 'original', { source: 'local', sourceUrl: '' });
+      await provider.set('update-key', 'updated', { source: 'local', sourceUrl: '' });
+
+      const entry = await provider.get('update-key');
+      expect(entry?.content).toBe('updated');
+    });
+
+    it('should respect skipCache option', async () => {
+      await provider.set('skip-key', 'content', { source: 'local', sourceUrl: '' });
+
+      const entry = await provider.get('skip-key', { skipCache: true });
+      expect(entry).toBeNull();
+    });
+
+    it('should apply custom tags', async () => {
+      await provider.set(
+        'tagged-key',
+        'content',
+        { source: 'local', sourceUrl: '' },
+        { tags: ['docs', 'api'] }
+      );
+
+      const metadata = await provider.getMetadata('tagged-key');
+      expect(metadata?.tags).toEqual(['docs', 'api']);
+    });
+  });
+
+  describe('getContent', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should return only content', async () => {
+      await provider.set('content-key', 'Just content', { source: 'local', sourceUrl: '' });
+
+      const content = await provider.getContent('content-key');
+      expect(content).toBe('Just content');
+    });
+
+    it('should return null for non-existent key', async () => {
+      const content = await provider.getContent('missing');
+      expect(content).toBeNull();
+    });
+  });
+
+  describe('has', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should return true for existing key', async () => {
+      await provider.set('exists', 'content', { source: 'local', sourceUrl: '' });
+      expect(await provider.has('exists')).toBe(true);
+    });
+
+    it('should return false for non-existent key', async () => {
+      expect(await provider.has('not-exists')).toBe(false);
+    });
+  });
+
+  describe('delete', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should delete existing entry', async () => {
+      await provider.set('delete-me', 'content', { source: 'local', sourceUrl: '' });
+      expect(await provider.has('delete-me')).toBe(true);
+
+      const result = await provider.delete('delete-me');
+      expect(result).toBe(true);
+      expect(await provider.has('delete-me')).toBe(false);
+    });
+
+    it('should return false for non-existent key', async () => {
+      const result = await provider.delete('not-exists');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getStatus', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should return valid for fresh entry', async () => {
+      await provider.set('fresh', 'content', { source: 'local', sourceUrl: '' }, { ttl: 3600 });
+
+      const status = await provider.getStatus('fresh');
+      expect(status).toBe('valid');
+    });
+
+    it('should return null for non-existent key', async () => {
+      const status = await provider.getStatus('missing');
+      expect(status).toBeNull();
+    });
+
+    it('should return expired for old entry', async () => {
+      // Create provider with very short TTL
+      const shortTtlProvider = new FileCacheProvider({
+        basePath: testDir,
+        ttl: -1, // Already expired
+      });
+      await shortTtlProvider.initialize();
+
+      await shortTtlProvider.set('expired', 'content', { source: 'local', sourceUrl: '' });
+
+      const status = await shortTtlProvider.getStatus('expired');
+      expect(status).toBe('expired');
+    });
+  });
+
+  describe('getMetadata', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should return metadata for existing entry', async () => {
+      await provider.set('meta-key', 'content', {
+        source: 'confluence',
+        sourceUrl: 'https://confluence.example.com/page',
+        title: 'Test Page',
+      });
+
+      const metadata = await provider.getMetadata('meta-key');
+
+      expect(metadata).not.toBeNull();
+      expect(metadata?.key).toBe('meta-key');
+      expect(metadata?.source).toBe('confluence');
+      expect(metadata?.title).toBe('Test Page');
+      expect(metadata?.contentHash).toBeDefined();
+    });
+
+    it('should return null for non-existent key', async () => {
+      const metadata = await provider.getMetadata('missing');
+      expect(metadata).toBeNull();
+    });
+  });
+
+  describe('updateMetadata', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should update metadata fields', async () => {
+      await provider.set('update-meta', 'content', { source: 'local', sourceUrl: '' });
+
+      await provider.updateMetadata('update-meta', { title: 'New Title', tags: ['updated'] });
+
+      const metadata = await provider.getMetadata('update-meta');
+      expect(metadata?.title).toBe('New Title');
+      expect(metadata?.tags).toEqual(['updated']);
+    });
+
+    it('should throw for non-existent key', async () => {
+      await expect(provider.updateMetadata('missing', { title: 'New' })).rejects.toThrow(
+        CacheError
+      );
+    });
+
+    it('should not change the key', async () => {
+      await provider.set('original-key', 'content', { source: 'local', sourceUrl: '' });
+
+      // Try to change key (should be ignored)
+      await provider.updateMetadata('original-key', { key: 'new-key' } as Partial<CacheMetadata>);
+
+      const metadata = await provider.getMetadata('original-key');
+      expect(metadata?.key).toBe('original-key');
+    });
+  });
+
+  describe('list', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+
+      // Add test entries
+      await provider.set(
+        'github-1',
+        'content',
+        { source: 'github', sourceUrl: '' },
+        { tags: ['docs'] }
+      );
+      await provider.set(
+        'github-2',
+        'content',
+        { source: 'github', sourceUrl: '' },
+        { tags: ['api'] }
+      );
+      await provider.set(
+        'confluence-1',
+        'content',
+        { source: 'confluence', sourceUrl: '' },
+        { tags: ['docs'] }
+      );
+    });
+
+    it('should list all entries', async () => {
+      const entries = await provider.list();
+      expect(entries).toHaveLength(3);
+    });
+
+    it('should filter by source', async () => {
+      const entries = await provider.list({ source: 'github' });
+      expect(entries).toHaveLength(2);
+      expect(entries.every((e) => e.source === 'github')).toBe(true);
+    });
+
+    it('should filter by tag', async () => {
+      const entries = await provider.list({ tag: 'docs' });
+      expect(entries).toHaveLength(2);
+    });
+
+    it('should apply limit', async () => {
+      const entries = await provider.list({ limit: 2 });
+      expect(entries).toHaveLength(2);
+    });
+  });
+
+  describe('getStats', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+    });
+
+    it('should return empty stats for empty cache', async () => {
+      const stats = await provider.getStats();
+
+      expect(stats.totalEntries).toBe(0);
+      expect(stats.totalSize).toBe(0);
+      expect(stats.validEntries).toBe(0);
+    });
+
+    it('should track entries and size', async () => {
+      await provider.set('key-1', 'content-1', { source: 'github', sourceUrl: '' });
+      await provider.set('key-2', 'content-2', { source: 'confluence', sourceUrl: '' });
+
+      const stats = await provider.getStats();
+
+      expect(stats.totalEntries).toBe(2);
+      expect(stats.totalSize).toBeGreaterThan(0);
+      expect(stats.bySource.github).toBe(1);
+      expect(stats.bySource.confluence).toBe(1);
+    });
+  });
+
+  describe('clear', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+      await provider.set('key-1', 'content', { source: 'local', sourceUrl: '' });
+      await provider.set('key-2', 'content', { source: 'local', sourceUrl: '' });
+    });
+
+    it('should clear all entries', async () => {
+      const count = await provider.clear();
+
+      expect(count).toBe(2);
+      expect(await provider.has('key-1')).toBe(false);
+      expect(await provider.has('key-2')).toBe(false);
+    });
+
+    it('should reset stats', async () => {
+      await provider.clear();
+
+      const stats = await provider.getStats();
+      expect(stats.totalEntries).toBe(0);
+      expect(stats.totalSize).toBe(0);
+    });
+  });
+
+  describe('clearExpired', () => {
+    it('should clear only expired entries', async () => {
+      // Create provider with short TTL
+      const shortProvider = new FileCacheProvider({
+        basePath: testDir,
+        ttl: -1,
+      });
+      await shortProvider.initialize();
+
+      await shortProvider.set('expired', 'content', { source: 'local', sourceUrl: '' });
+
+      // Create fresh entry with long TTL
+      const longProvider = new FileCacheProvider({
+        basePath: testDir,
+        ttl: 86400,
+      });
+      await longProvider.initialize();
+      await longProvider.set('fresh', 'content', { source: 'local', sourceUrl: '' });
+
+      const count = await longProvider.clearExpired();
+      expect(count).toBe(1);
+      expect(await longProvider.has('fresh')).toBe(true);
+    });
+  });
+
+  describe('clearBySource', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+      await provider.set('github-1', 'content', { source: 'github', sourceUrl: '' });
+      await provider.set('github-2', 'content', { source: 'github', sourceUrl: '' });
+      await provider.set('local-1', 'content', { source: 'local', sourceUrl: '' });
+    });
+
+    it('should clear entries by source', async () => {
+      const count = await provider.clearBySource('github');
+
+      expect(count).toBe(2);
+      expect(await provider.has('github-1')).toBe(false);
+      expect(await provider.has('github-2')).toBe(false);
+      expect(await provider.has('local-1')).toBe(true);
+    });
+  });
+
+  describe('clearByTag', () => {
+    beforeEach(async () => {
+      await provider.initialize();
+      await provider.set(
+        'docs-1',
+        'content',
+        { source: 'local', sourceUrl: '' },
+        { tags: ['docs'] }
+      );
+      await provider.set(
+        'docs-2',
+        'content',
+        { source: 'local', sourceUrl: '' },
+        { tags: ['docs', 'api'] }
+      );
+      await provider.set(
+        'other',
+        'content',
+        { source: 'local', sourceUrl: '' },
+        { tags: ['other'] }
+      );
+    });
+
+    it('should clear entries by tag', async () => {
+      const count = await provider.clearByTag('docs');
+
+      expect(count).toBe(2);
+      expect(await provider.has('docs-1')).toBe(false);
+      expect(await provider.has('docs-2')).toBe(false);
+      expect(await provider.has('other')).toBe(true);
+    });
+  });
+});
+
+describe('createFileCacheProvider', () => {
+  it('should create a provider instance', () => {
+    const provider = createFileCacheProvider({ basePath: '/tmp' });
+    expect(provider).toBeInstanceOf(FileCacheProvider);
+  });
+});