@deimoscloud/coreai 0.1.8 → 0.1.10

package/src/cache/provider.test.ts

@@ -1,485 +0,0 @@
-/**
- * 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);
-  });
-});