bunsane 0.3.1 → 0.4.0

package/tests/unit/BatchLoader.test.ts

@@ -1,196 +0,0 @@
-/**
- * Unit tests for BatchLoader TTL behavior and bounded cache
- */
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { BatchLoader } from '../../core/BatchLoader';
-
-describe('BatchLoader', () => {
-    beforeEach(() => {
-        BatchLoader.clearCache();
-    });
-
-    describe('getCacheStats()', () => {
-        test('returns zero stats when cache is empty', () => {
-            const stats = BatchLoader.getCacheStats();
-            expect(stats.size).toBe(0);
-            expect(stats.entries).toBe(0);
-            expect(stats.expired).toBe(0);
-        });
-
-        test('includes memory estimate', () => {
-            const stats = BatchLoader.getCacheStats();
-            expect(stats.memoryEstimate).toBeDefined();
-            expect(typeof stats.memoryEstimate).toBe('string');
-        });
-    });
-
-    describe('clearCache()', () => {
-        test('clears all cached entries', () => {
-            // Access internal cache to set up test data
-            const cache = (BatchLoader as any).cache;
-            const now = Date.now();
-
-            // Use the cache's set method to add entries
-            cache.set('type1\x00value', 'parent1', {
-                ids: ['a', 'b'],
-                expiresAt: now + 300000,
-                lastAccessed: now
-            });
-
-            expect(BatchLoader.getCacheStats().entries).toBe(1);
-
-            BatchLoader.clearCache();
-            expect(BatchLoader.getCacheStats().entries).toBe(0);
-        });
-    });
-
-    describe('TTL expiry', () => {
-        test('getCacheStats reports expired entries', () => {
-            const cache = (BatchLoader as any).cache;
-            const now = Date.now();
-
-            // One fresh entry
-            cache.set('type1\x00value', 'parent1', {
-                ids: ['a'],
-                expiresAt: now + 300000,
-                lastAccessed: now
-            });
-            // One expired entry
-            cache.set('type1\x00value', 'parent2', {
-                ids: ['b'],
-                expiresAt: now - 1000,
-                lastAccessed: now - 1000
-            });
-
-            const stats = BatchLoader.getCacheStats();
-            expect(stats.entries).toBe(2);
-            expect(stats.expired).toBe(1);
-        });
-
-        test('expired entries are counted correctly for multiple type keys', () => {
-            const cache = (BatchLoader as any).cache;
-            const now = Date.now();
-
-            // Type 1 entries
-            cache.set('type1\x00field', 'p1', {
-                ids: ['a'],
-                expiresAt: now - 5000,
-                lastAccessed: now - 5000
-            });
-            cache.set('type1\x00field', 'p2', {
-                ids: ['b'],
-                expiresAt: now + 300000,
-                lastAccessed: now
-            });
-
-            // Type 2 entry
-            cache.set('type2\x00field', 'p3', {
-                ids: ['c'],
-                expiresAt: now - 1000,
-                lastAccessed: now - 1000
-            });
-
-            const stats = BatchLoader.getCacheStats();
-            expect(stats.size).toBe(2);
-            expect(stats.entries).toBe(3);
-            expect(stats.expired).toBe(2);
-        });
-
-        test('all entries fresh means zero expired', () => {
-            const cache = (BatchLoader as any).cache;
-            const now = Date.now();
-
-            cache.set('type\x00field', 'p1', {
-                ids: ['a'],
-                expiresAt: now + 60000,
-                lastAccessed: now
-            });
-            cache.set('type\x00field', 'p2', {
-                ids: ['b'],
-                expiresAt: now + 60000,
-                lastAccessed: now
-            });
-            cache.set('type\x00field', 'p3', {
-                ids: ['c'],
-                expiresAt: now + 60000,
-                lastAccessed: now
-            });
-
-            const stats = BatchLoader.getCacheStats();
-            expect(stats.entries).toBe(3);
-            expect(stats.expired).toBe(0);
-        });
-    });
-
-    describe('pruneExpiredEntries()', () => {
-        test('removes expired entries and returns count', () => {
-            const cache = (BatchLoader as any).cache;
-            const now = Date.now();
-
-            // Add mix of fresh and expired entries
-            cache.set('type\x00field', 'p1', {
-                ids: ['a'],
-                expiresAt: now - 5000,
-                lastAccessed: now - 5000
-            });
-            cache.set('type\x00field', 'p2', {
-                ids: ['b'],
-                expiresAt: now + 300000,
-                lastAccessed: now
-            });
-            cache.set('type\x00field', 'p3', {
-                ids: ['c'],
-                expiresAt: now - 1000,
-                lastAccessed: now - 1000
-            });
-
-            expect(BatchLoader.getCacheStats().entries).toBe(3);
-            expect(BatchLoader.getCacheStats().expired).toBe(2);
-
-            const pruned = BatchLoader.pruneExpiredEntries();
-            expect(pruned).toBe(2);
-
-            const statsAfter = BatchLoader.getCacheStats();
-            expect(statsAfter.entries).toBe(1);
-            expect(statsAfter.expired).toBe(0);
-        });
-
-        test('returns 0 when no expired entries', () => {
-            const cache = (BatchLoader as any).cache;
-            const now = Date.now();
-
-            cache.set('type\x00field', 'p1', {
-                ids: ['a'],
-                expiresAt: now + 60000,
-                lastAccessed: now
-            });
-
-            const pruned = BatchLoader.pruneExpiredEntries();
-            expect(pruned).toBe(0);
-        });
-    });
-
-    describe('bounded cache behavior', () => {
-        test('memory estimate increases with entries', () => {
-            const cache = (BatchLoader as any).cache;
-            const now = Date.now();
-
-            const statsBefore = BatchLoader.getCacheStats();
-
-            // Add several entries
-            for (let i = 0; i < 100; i++) {
-                cache.set(`type${i}\x00field`, `parent${i}`, {
-                    ids: [`id${i}`],
-                    expiresAt: now + 60000,
-                    lastAccessed: now
-                });
-            }
-
-            const statsAfter = BatchLoader.getCacheStats();
-            expect(statsAfter.entries).toBe(100);
-
-            // Memory estimate should reflect the entries
-            expect(statsAfter.memoryEstimate).toBeDefined();
-        });
-    });
-});

package/tests/unit/archetype/ArcheType.test.ts

@@ -1,107 +0,0 @@
-/**
- * Unit tests for ArcheType system
- * Tests archetype definition and basic functionality
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { BaseArcheType, ArcheType, ArcheTypeField } from '../../../core/ArcheType';
-import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
-import { TestUserArchetype, TestUserWithOrdersArchetype } from '../../fixtures/archetypes/TestUserArchetype';
-import { ensureComponentsRegistered } from '../../utils';
-
-describe('ArcheType', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
-    });
-
-    describe('ArcheType definition', () => {
-        test('archetype class extends BaseArcheType', () => {
-            const archetype = new TestUserArchetype();
-            expect(archetype).toBeInstanceOf(BaseArcheType);
-        });
-
-        test('archetype has componentMap', () => {
-            const archetype = new TestUserArchetype();
-            expect(archetype.componentMap).toBeDefined();
-            expect(typeof archetype.componentMap).toBe('object');
-        });
-
-        test('componentMap contains declared fields', () => {
-            const archetype = new TestUserArchetype();
-            expect(archetype.componentMap.user).toBeDefined();
-        });
-
-        test('archetype with multiple components', () => {
-            const archetype = new TestUserWithOrdersArchetype();
-            expect(archetype.componentMap.user).toBeDefined();
-            expect(archetype.componentMap.order).toBeDefined();
-        });
-    });
-
-    describe('createEntity()', () => {
-        test('creates entity with id', () => {
-            const archetype = new TestUserArchetype();
-            const entity = archetype.createEntity();
-
-            expect(entity).toBeDefined();
-            expect(entity.id).toBeDefined();
-            expect(entity.id.length).toBeGreaterThan(0);
-        });
-
-        test('entity is dirty after creation', () => {
-            const archetype = new TestUserArchetype();
-            const entity = archetype.createEntity();
-
-            expect((entity as any)._dirty).toBe(true);
-        });
-
-        test('entity is not persisted after creation', () => {
-            const archetype = new TestUserArchetype();
-            const entity = archetype.createEntity();
-
-            expect(entity._persisted).toBe(false);
-        });
-    });
-
-    describe('getZodObjectSchema()', () => {
-        test('returns zod schema for archetype', () => {
-            const archetype = new TestUserArchetype();
-            const schema = archetype.getZodObjectSchema();
-
-            expect(schema).toBeDefined();
-        });
-    });
-
-    describe('getInputSchema()', () => {
-        test('returns input schema for archetype', () => {
-            const archetype = new TestUserArchetype();
-            const schema = archetype.getInputSchema();
-
-            expect(schema).toBeDefined();
-        });
-    });
-
-    describe('getComponentsToLoad()', () => {
-        test('returns non-empty components array', () => {
-            const archetype = new TestUserArchetype();
-            const components = (archetype as any).getComponentsToLoad();
-
-            expect(Array.isArray(components)).toBe(true);
-            expect(components.length).toBeGreaterThan(0);
-            expect(components).toContain(TestUser);
-        });
-    });
-
-    describe('withValidation()', () => {
-        test('returns a Zod schema with validations applied', () => {
-            const archetype = new TestUserArchetype();
-            const schema = archetype.withValidation({
-                user: { name: 'Valid', email: 'valid@test.com', age: 25 }
-            });
-
-            expect(schema).toBeDefined();
-            // Should return a Zod schema with a shape property
-            expect(schema.shape).toBeDefined();
-            expect(typeof schema.safeParse).toBe('function');
-        });
-    });
-});

package/tests/unit/cache/CacheManager.test.ts

@@ -1,367 +0,0 @@
-/**
- * Unit tests for CacheManager
- * Tests cache configuration and management
- */
-import { describe, test, expect, beforeEach, afterEach, mock } from 'bun:test';
-import { CacheManager } from '../../../core/cache/CacheManager';
-import { MemoryCache } from '../../../core/cache/MemoryCache';
-import { MultiLevelCache } from '../../../core/cache/MultiLevelCache';
-
-describe('CacheManager', () => {
-    let cacheManager: CacheManager;
-
-    beforeEach(async () => {
-        cacheManager = CacheManager.getInstance();
-        await cacheManager.initialize({
-            enabled: true,
-            provider: 'memory',
-            strategy: 'write-through',
-            defaultTTL: 3600000,
-            entity: { enabled: true, ttl: 3600000 },
-            component: { enabled: true, ttl: 1800000 },
-            query: { enabled: false, ttl: 300000, maxSize: 10000 }
-        });
-    });
-
-    afterEach(async () => {
-        await cacheManager.clear();
-    });
-
-    describe('getInstance()', () => {
-        test('returns singleton instance', () => {
-            const instance1 = CacheManager.getInstance();
-            const instance2 = CacheManager.getInstance();
-            expect(instance1).toBe(instance2);
-        });
-
-        test('returns defined instance', () => {
-            const instance = CacheManager.getInstance();
-            expect(instance).toBeDefined();
-        });
-    });
-
-    describe('initialize()', () => {
-        test('applies configuration', async () => {
-            await cacheManager.initialize({
-                enabled: true,
-                provider: 'memory',
-                defaultTTL: 5000
-            });
-
-            const config = cacheManager.getConfig();
-            expect(config.enabled).toBe(true);
-            expect(config.provider).toBe('memory');
-            expect(config.defaultTTL).toBe(5000);
-        });
-
-        test('can disable cache', async () => {
-            await cacheManager.initialize({ enabled: false });
-            const config = cacheManager.getConfig();
-            expect(config.enabled).toBe(false);
-        });
-    });
-
-    describe('getConfig()', () => {
-        test('returns configuration object', () => {
-            const config = cacheManager.getConfig();
-            expect(config).toBeDefined();
-            expect(typeof config.enabled).toBe('boolean');
-        });
-
-        test('returns copy of configuration', () => {
-            const config1 = cacheManager.getConfig();
-            const config2 = cacheManager.getConfig();
-            expect(config1).not.toBe(config2);
-            expect(config1).toEqual(config2);
-        });
-    });
-
-    describe('getProvider()', () => {
-        test('returns cache provider', () => {
-            const provider = cacheManager.getProvider();
-            expect(provider).toBeDefined();
-        });
-    });
-
-    describe('generic cache operations', () => {
-        test('get returns null for missing key', async () => {
-            const result = await cacheManager.get('non-existent-key');
-            expect(result).toBeNull();
-        });
-
-        test('set and get work correctly', async () => {
-            await cacheManager.set('test-key', { data: 'value' });
-            const result = await cacheManager.get<{ data: string }>('test-key');
-            expect(result).toEqual({ data: 'value' });
-        });
-
-        test('set respects TTL', async () => {
-            await cacheManager.set('test-key', 'value', 100);
-            const immediate = await cacheManager.get('test-key');
-            expect(immediate).toBe('value');
-
-            // Wait for TTL to expire
-            await new Promise(resolve => setTimeout(resolve, 150));
-            const expired = await cacheManager.get('test-key');
-            expect(expired).toBeNull();
-        });
-
-        test('delete removes key', async () => {
-            await cacheManager.set('test-key', 'value');
-            await cacheManager.delete('test-key');
-            const result = await cacheManager.get('test-key');
-            expect(result).toBeNull();
-        });
-
-        test('clear removes all keys', async () => {
-            await cacheManager.set('key1', 'value1');
-            await cacheManager.set('key2', 'value2');
-            await cacheManager.clear();
-
-            const result1 = await cacheManager.get('key1');
-            const result2 = await cacheManager.get('key2');
-            expect(result1).toBeNull();
-            expect(result2).toBeNull();
-        });
-    });
-
-    describe('entity cache operations', () => {
-        test('getEntity returns null for missing entity', async () => {
-            const result = await cacheManager.getEntity('missing-id');
-            expect(result).toBeNull();
-        });
-
-        test('invalidateEntity removes entity from cache', async () => {
-            // Manually set entity cache
-            const provider = cacheManager.getProvider();
-            await provider.set('entity:test-id', 'test-id', 3600000);
-
-            await cacheManager.invalidateEntity('test-id');
-            const result = await cacheManager.getEntity('test-id');
-            expect(result).toBeNull();
-        });
-
-        test('invalidateEntities clears entity + all component caches for a batch', async () => {
-            const provider = cacheManager.getProvider();
-            // Two entities, each with cached entity entry + one component
-            await provider.set('entity:e1', 'e1', 3600000);
-            await provider.set('entity:e2', 'e2', 3600000);
-            await provider.set('component:e1:t1', { data: 'a' }, 3600000);
-            await provider.set('component:e2:t1', { data: 'b' }, 3600000);
-
-            await cacheManager.invalidateEntities(['e1', 'e2']);
-
-            expect(await cacheManager.getEntity('e1')).toBeNull();
-            expect(await cacheManager.getEntity('e2')).toBeNull();
-            expect(await cacheManager.getComponentsByEntity('e1', 't1')).toBeNull();
-            expect(await cacheManager.getComponentsByEntity('e2', 't1')).toBeNull();
-        });
-
-        test('invalidateEntities is a noop for empty list', async () => {
-            await expect(cacheManager.invalidateEntities([])).resolves.toBeUndefined();
-        });
-
-        test('getEntities returns null for missing entities', async () => {
-            const results = await cacheManager.getEntities(['id1', 'id2', 'id3']);
-            expect(results.length).toBe(3);
-            expect(results.every(r => r === null)).toBe(true);
-        });
-    });
-
-    describe('component cache operations', () => {
-        test('getComponentsByEntity returns null for missing components', async () => {
-            const result = await cacheManager.getComponentsByEntity('entity-id');
-            expect(result).toBeNull();
-        });
-
-        test('invalidateComponent removes specific component', async () => {
-            // Manually set component cache
-            const provider = cacheManager.getProvider();
-            await provider.set('component:entity-id:type-id', { data: 'test' }, 3600000);
-
-            await cacheManager.invalidateComponent('entity-id', 'type-id');
-            const result = await cacheManager.getComponentsByEntity('entity-id', 'type-id');
-            expect(result).toBeNull();
-        });
-
-        test('invalidateComponents removes multiple components', async () => {
-            const provider = cacheManager.getProvider();
-            await provider.set('component:e1:t1', { data: 'test1' }, 3600000);
-            await provider.set('component:e2:t2', { data: 'test2' }, 3600000);
-
-            await cacheManager.invalidateComponents([
-                { entityId: 'e1', typeId: 't1' },
-                { entityId: 'e2', typeId: 't2' }
-            ]);
-
-            const result1 = await provider.get('component:e1:t1');
-            const result2 = await provider.get('component:e2:t2');
-            expect(result1).toBeNull();
-            expect(result2).toBeNull();
-        });
-
-        test('getComponents returns null for missing components', async () => {
-            const results = await cacheManager.getComponents([
-                { entityId: 'e1', typeId: 't1' },
-                { entityId: 'e2', typeId: 't2' }
-            ]);
-            expect(results.length).toBe(2);
-            expect(results.every(r => r === null)).toBe(true);
-        });
-    });
-
-    describe('cache disabled', () => {
-        beforeEach(async () => {
-            await cacheManager.initialize({ enabled: false });
-        });
-
-        test('get returns null when disabled', async () => {
-            const result = await cacheManager.get('key');
-            expect(result).toBeNull();
-        });
-
-        test('set does nothing when disabled', async () => {
-            await cacheManager.set('key', 'value');
-            // Re-enable to check
-            await cacheManager.initialize({ enabled: true, provider: 'memory' });
-            const result = await cacheManager.get('key');
-            expect(result).toBeNull();
-        });
-
-        test('getEntity returns null when disabled', async () => {
-            const result = await cacheManager.getEntity('id');
-            expect(result).toBeNull();
-        });
-
-        test('getComponentsByEntity returns null when disabled', async () => {
-            const result = await cacheManager.getComponentsByEntity('id');
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('getStats()', () => {
-        test('returns statistics object', async () => {
-            const stats = await cacheManager.getStats();
-            expect(stats).toBeDefined();
-            expect(typeof stats.hits).toBe('number');
-            expect(typeof stats.misses).toBe('number');
-        });
-    });
-
-    describe('ping()', () => {
-        test('returns true for healthy cache', async () => {
-            const result = await cacheManager.ping();
-            expect(result).toBe(true);
-        });
-    });
-
-    describe('shutdown()', () => {
-        test('calls stopCleanup on MemoryCache provider', async () => {
-            await cacheManager.initialize({
-                enabled: true,
-                provider: 'memory',
-                defaultTTL: 3600000
-            });
-
-            const provider = cacheManager.getProvider() as MemoryCache;
-            const stopCleanupSpy = mock(() => {});
-            (provider as any).stopCleanup = stopCleanupSpy;
-
-            await cacheManager.shutdown();
-            expect(stopCleanupSpy).toHaveBeenCalled();
-        });
-
-        test('shutdown does not throw on NoOp provider', async () => {
-            await cacheManager.initialize({ enabled: false });
-            await expect(cacheManager.shutdown()).resolves.toBeUndefined();
-        });
-    });
-
-    describe('initialize() cleanup', () => {
-        test('shuts down old provider when reinitializing', async () => {
-            await cacheManager.initialize({
-                enabled: true,
-                provider: 'memory',
-                defaultTTL: 3600000
-            });
-
-            const oldProvider = cacheManager.getProvider() as MemoryCache;
-            const stopCleanupSpy = mock(() => {});
-            (oldProvider as any).stopCleanup = stopCleanupSpy;
-
-            // Reinitialize with new config
-            await cacheManager.initialize({
-                enabled: true,
-                provider: 'memory',
-                defaultTTL: 5000
-            });
-
-            expect(stopCleanupSpy).toHaveBeenCalled();
-        });
-    });
-
-    describe('cross-instance invalidation (pub/sub)', () => {
-        test('pub/sub not enabled for memory-only provider', async () => {
-            await cacheManager.initialize({
-                enabled: true,
-                provider: 'memory',
-                defaultTTL: 3600000
-            });
-
-            // pubSubEnabled is private, so we test indirectly:
-            // publishInvalidation should be a no-op (no errors, no side effects)
-            await cacheManager.set('test-key', 'value');
-            await cacheManager.delete('test-key');
-            // If pub/sub were broken for memory provider, this would throw
-            const result = await cacheManager.get('test-key');
-            expect(result).toBeNull();
-        });
-
-        test('invalidateEntity still works without pub/sub', async () => {
-            const provider = cacheManager.getProvider();
-            await provider.set('entity:abc', 'abc', 3600000);
-
-            await cacheManager.invalidateEntity('abc');
-            const result = await provider.get('entity:abc');
-            expect(result).toBeNull();
-        });
-
-        test('invalidateComponent still works without pub/sub', async () => {
-            const provider = cacheManager.getProvider();
-            await provider.set('component:e1:t1', { data: 'test' }, 3600000);
-
-            await cacheManager.invalidateComponent('e1', 't1');
-            const result = await provider.get('component:e1:t1');
-            expect(result).toBeNull();
-        });
-
-        test('clear still works without pub/sub', async () => {
-            await cacheManager.set('key1', 'v1');
-            await cacheManager.set('key2', 'v2');
-
-            await cacheManager.clear();
-            expect(await cacheManager.get('key1')).toBeNull();
-            expect(await cacheManager.get('key2')).toBeNull();
-        });
-
-        test('handleRemoteInvalidation ignores messages from self', async () => {
-            // Access private method via any
-            const cm = cacheManager as any;
-            const myId = cm.instanceId;
-
-            // Simulate receiving our own message — should NOT invalidate
-            await cacheManager.set('survive-key', 'should-survive');
-
-            // Call private method directly
-            await cm.handleRemoteInvalidation(JSON.stringify({
-                instanceId: myId,
-                type: 'key',
-                keys: ['survive-key']
-            }));
-
-            // Key should still exist because self-messages are ignored
-            const result = await cacheManager.get('survive-key');
-            expect(result).toBe('should-survive');
-        });
-    });
-});