bunsane 0.1.4 → 0.2.0

package/tests/integration/cache/CacheInvalidation.test.ts

@@ -0,0 +1,259 @@
+/**
+ * Integration tests for Cache Invalidation
+ * Tests cache behavior with entity operations
+ */
+import { describe, test, expect, beforeAll, beforeEach, afterEach } from 'bun:test';
+import { Entity } from '../../../core/Entity';
+import { Query } from '../../../query/Query';
+import { CacheManager } from '../../../core/cache/CacheManager';
+import { TestUser, TestProduct } from '../../fixtures/components';
+import { createTestContext, ensureComponentsRegistered, delay } from '../../utils';
+
+describe('Cache Invalidation', () => {
+    const ctx = createTestContext();
+
+    beforeAll(async () => {
+        await ensureComponentsRegistered(TestUser, TestProduct);
+    });
+
+    beforeEach(async () => {
+        // Ensure cache is enabled for these tests
+        await ctx.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 }
+        });
+    });
+
+    describe('entity cache on save', () => {
+        test('entity is cached after save', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'CacheOnSave', email: 'cache@example.com', age: 30 });
+            await entity.save();
+
+            // Give async cache operations time to complete
+            await delay(50);
+
+            const cached = await ctx.cacheManager.getEntity(entity.id);
+            expect(cached).toBe(entity.id);
+        });
+
+        test('component is cached after save with write-through', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'CompCache', email: 'compcache@example.com', age: 25 });
+            await entity.save();
+
+            // Give async cache operations time to complete
+            await delay(50);
+
+            const user = entity.getInMemory(TestUser);
+            expect(user).toBeDefined();
+            const typeId = user?.getTypeID();
+            expect(typeId).toBeDefined();
+
+            // With write-through, component data should be in cache
+            const cached = await ctx.cacheManager.getComponentsByEntity(entity.id, typeId);
+            expect(cached).not.toBeUndefined();
+        });
+    });
+
+    describe('cache invalidation on delete', () => {
+        test('entity cache is invalidated on delete', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'ToInvalidate', email: 'invalidate@example.com', age: 30 });
+            await entity.save();
+
+            await delay(50);
+            const cachedBefore = await ctx.cacheManager.getEntity(entity.id);
+            expect(cachedBefore).toBe(entity.id);
+
+            await entity.delete(true);
+            await delay(50);
+
+            const cachedAfter = await ctx.cacheManager.getEntity(entity.id);
+            expect(cachedAfter).toBeNull();
+        });
+
+        test('component cache is invalidated on delete', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'CompInvalidate', email: 'compinv@example.com', age: 28 });
+            await entity.save();
+
+            const user = entity.getInMemory(TestUser);
+            const typeId = user?.getTypeID();
+
+            await entity.delete(true);
+            await delay(50);
+
+            const cached = await ctx.cacheManager.getComponentsByEntity(entity.id, typeId);
+            expect(cached).toBeNull();
+        });
+    });
+
+    describe('component cache on update', () => {
+        test('cache updates on component modification', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Original', email: 'original@example.com', age: 25 });
+            await entity.save();
+
+            await delay(50);
+
+            // Update component
+            await entity.set(TestUser, { name: 'Updated' });
+            await entity.save();
+
+            await delay(50);
+
+            // Load fresh from DB using Query with component
+            const results = await new Query().findById(entity.id).with(TestUser).exec();
+            const loaded = results[0];
+            const userData = await loaded?.get(TestUser);
+            expect(userData?.name).toBe('Updated');
+        });
+
+        test('removed component is invalidated from cache', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'ToRemove', email: 'remove@example.com', age: 30 });
+            entity.add(TestProduct, { sku: 'REMOVE', name: 'Remove Prod', price: 10, inStock: true });
+            await entity.save();
+
+            await delay(50);
+
+            // Remove component
+            entity.remove(TestProduct);
+            await entity.save();
+
+            await delay(100);
+
+            // Verify component is gone using get() to load from database
+            const loaded = await Entity.FindById(entity.id);
+            const productData = await loaded?.get(TestProduct);
+            expect(productData).toBeNull();
+        });
+    });
+
+    describe('write-through vs write-invalidate', () => {
+        test('write-through strategy updates cache on save', async () => {
+            await ctx.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 }
+            });
+
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'WriteThrough', email: 'wt@example.com', age: 30 });
+            await entity.save();
+
+            await delay(50);
+
+            const cached = await ctx.cacheManager.getEntity(entity.id);
+            expect(cached).toBe(entity.id);
+        });
+
+        test('write-invalidate strategy invalidates stale cache on save', async () => {
+            await ctx.cacheManager.initialize({
+                enabled: true,
+                provider: 'memory',
+                strategy: 'write-invalidate',
+                defaultTTL: 3600000,
+                entity: { enabled: true, ttl: 3600000 },
+                component: { enabled: true, ttl: 1800000 },
+                query: { enabled: false, ttl: 300000, maxSize: 10000 }
+            });
+
+            // Pre-populate cache with stale data
+            const provider = ctx.cacheManager.getProvider();
+            await provider.set('entity:stale-test-id', 'stale-test-id', 3600000);
+
+            // Verify stale data is in cache
+            const before = await provider.get('entity:stale-test-id');
+            expect(before).toBe('stale-test-id');
+
+            // Now create and save a real entity — this triggers invalidation
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'WriteInvalidate', email: 'wi@example.com', age: 25 });
+            await entity.save();
+
+            await delay(100);
+
+            // The entity we saved should be retrievable from DB
+            const loaded = await Entity.FindById(entity.id);
+            expect(loaded).not.toBeNull();
+            expect(loaded?.id).toBe(entity.id);
+        });
+    });
+
+    describe('cache disabled', () => {
+        beforeEach(async () => {
+            await ctx.cacheManager.initialize({ enabled: false });
+        });
+
+        test('operations work without cache', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'NoCache', email: 'nocache@example.com', age: 30 });
+            await entity.save();
+
+            const loaded = await Entity.FindById(entity.id);
+            expect(loaded).not.toBeNull();
+            expect(loaded?.id).toBe(entity.id);
+        });
+
+        test('getEntity returns null when disabled', async () => {
+            const result = await ctx.cacheManager.getEntity('any-id');
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('cache consistency', () => {
+        test('multiple updates maintain consistency', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Consistency1', email: 'cons@example.com', age: 20 });
+            await entity.save();
+
+            for (let i = 2; i <= 5; i++) {
+                await entity.set(TestUser, { name: `Consistency${i}`, age: 20 + i });
+                await entity.save();
+                await delay(20);
+            }
+
+            // Load using Query with component to get data in memory
+            const results = await new Query().findById(entity.id).with(TestUser).exec();
+            const loaded = results[0];
+            const userData = await loaded?.get(TestUser);
+            expect(userData?.name).toBe('Consistency5');
+            expect(userData?.age).toBe(25);
+        });
+
+        test('concurrent saves maintain data integrity', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Concurrent', email: 'concurrent@example.com', age: 30 });
+            await entity.save();
+
+            // Multiple updates in parallel
+            const updates = [
+                entity.set(TestUser, { age: 31 }),
+                entity.set(TestUser, { age: 32 }),
+                entity.set(TestUser, { age: 33 })
+            ];
+
+            await Promise.all(updates);
+            await entity.save();
+            await delay(50);
+
+            // Load using Query with component
+            const results = await new Query().findById(entity.id).with(TestUser).exec();
+            const loaded = results[0];
+            const userData = await loaded?.get(TestUser);
+            // One of the ages should be set
+            expect([31, 32, 33]).toContain(userData?.age);
+        });
+    });
+});

package/tests/integration/entity/Entity.persistence.test.ts

@@ -0,0 +1,333 @@
+/**
+ * Integration tests for Entity persistence
+ * Tests entity CRUD operations with the database
+ */
+import { describe, test, expect, beforeAll, beforeEach, afterEach } from 'bun:test';
+import { Entity } from '../../../core/Entity';
+import { Query } from '../../../query/Query';
+import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
+import { createTestContext, ensureComponentsRegistered } from '../../utils';
+
+describe('Entity Persistence', () => {
+    const ctx = createTestContext();
+
+    beforeAll(async () => {
+        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
+    });
+
+    describe('save()', () => {
+        test('persists new entity to database', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'John Doe', email: 'john@example.com', age: 30 });
+
+            await entity.save();
+
+            expect(entity._persisted).toBe(true);
+            expect((entity as any)._dirty).toBe(false);
+        });
+
+        test('persists multiple components', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Jane', email: 'jane@example.com', age: 25 });
+            entity.add(TestProduct, { sku: 'SKU001', name: 'Test Product', price: 49.99, inStock: true });
+
+            await entity.save();
+
+            expect(entity._persisted).toBe(true);
+        });
+
+        test('updates existing entity', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Original', email: 'original@example.com', age: 20 });
+            await entity.save();
+
+            // Update the entity
+            await entity.set(TestUser, { name: 'Updated', age: 21 });
+            await entity.save();
+
+            // Verify update by loading from database using Query with component
+            const results = await new Query().findById(entity.id).with(TestUser).exec();
+            const loaded = results[0];
+            const user = await loaded?.get(TestUser);
+            expect(user?.name).toBe('Updated');
+            expect(user?.age).toBe(21);
+        });
+
+        test('saves entity with Date field', async () => {
+            const date = new Date('2024-06-15T10:30:00Z');
+            const entity = ctx.tracker.create();
+            entity.add(TestOrder, {
+                orderNumber: 'ORD-001',
+                total: 150.00,
+                status: 'pending',
+                createdAt: date
+            });
+
+            await entity.save();
+
+            // Load with Query specifying component
+            const results = await new Query().findById(entity.id).with(TestOrder).exec();
+            const loaded = results[0];
+            const order = await loaded?.get(TestOrder);
+            expect(order?.createdAt.toISOString()).toBe(date.toISOString());
+        });
+    });
+
+    describe('FindById()', () => {
+        test('loads entity by ID', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'FindMe', email: 'findme@example.com', age: 40 });
+            await entity.save();
+
+            const loaded = await Entity.FindById(entity.id);
+
+            expect(loaded).not.toBeNull();
+            expect(loaded?.id).toBe(entity.id);
+        });
+
+        test('returns null for non-existent ID', async () => {
+            const loaded = await Entity.FindById('00000000-0000-0000-0000-000000000000');
+            expect(loaded).toBeNull();
+        });
+
+        test('loads entity and components can be fetched via get()', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Multi', email: 'multi@example.com', age: 30 });
+            entity.add(TestProduct, { sku: 'MULTI', name: 'Multi Product', price: 10, inStock: true });
+            await entity.save();
+
+            const loaded = await Entity.FindById(entity.id);
+
+            // Use get() to load components from database
+            const userData = await loaded?.get(TestUser);
+            const productData = await loaded?.get(TestProduct);
+            expect(userData).toBeDefined();
+            expect(productData).toBeDefined();
+        });
+
+        test('returns null for empty string ID', async () => {
+            const loaded = await Entity.FindById('');
+            expect(loaded).toBeNull();
+        });
+    });
+
+    describe('Query with components', () => {
+        test('loads entity with components into memory', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'QueryLoad', email: 'queryload@example.com', age: 35 });
+            await entity.save();
+
+            // Use Query with .with() and .populate() to load component into memory
+            const results = await new Query().findById(entity.id).with(TestUser).populate().exec();
+            const loaded = results[0];
+
+            // After Query.with().populate(), component should be in memory
+            expect(loaded?.hasInMemory(TestUser)).toBe(true);
+            const userData = loaded?.getInMemory(TestUser);
+            expect(userData?.name).toBe('QueryLoad');
+        });
+
+        test('loads multiple components into memory', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'MultiQuery', email: 'multiquery@example.com', age: 25 });
+            entity.add(TestProduct, { sku: 'MQ001', name: 'Multi Query Product', price: 99.99, inStock: true });
+            await entity.save();
+
+            const results = await new Query()
+                .findById(entity.id)
+                .with(TestUser)
+                .with(TestProduct)
+                .populate()
+                .exec();
+            const loaded = results[0];
+
+            expect(loaded?.hasInMemory(TestUser)).toBe(true);
+            expect(loaded?.hasInMemory(TestProduct)).toBe(true);
+        });
+    });
+
+    describe('delete()', () => {
+        test('soft deletes entity', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'ToDelete', email: 'delete@example.com', age: 25 });
+            await entity.save();
+
+            await entity.delete();
+
+            const loaded = await Entity.FindById(entity.id);
+            expect(loaded).toBeNull();
+        });
+
+        test('hard deletes entity with force flag', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'HardDelete', email: 'hard@example.com', age: 30 });
+            await entity.save();
+
+            await entity.delete(true);
+
+            const loaded = await Entity.FindById(entity.id);
+            expect(loaded).toBeNull();
+        });
+
+        test('returns false for non-persisted entity', async () => {
+            const entity = new Entity();
+            const result = await entity.delete();
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('get()', () => {
+        test('loads component from database', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'LoadTest', email: 'load@example.com', age: 35 });
+            await entity.save();
+
+            // Create a fresh entity with same ID to simulate loading
+            const freshEntity = new Entity(entity.id);
+            freshEntity.setPersisted(true);
+            ctx.tracker.track(freshEntity);
+
+            const userData = await freshEntity.get(TestUser);
+
+            expect(userData).not.toBeNull();
+            expect(userData?.name).toBe('LoadTest');
+            expect(userData?.email).toBe('load@example.com');
+        });
+
+        test('returns null for non-existent component', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'NoProduct', email: 'noproduct@example.com', age: 20 });
+            await entity.save();
+
+            const productData = await entity.get(TestProduct);
+            expect(productData).toBeNull();
+        });
+
+        test('caches component after loading', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'CacheTest', email: 'cache@example.com', age: 30 });
+            await entity.save();
+
+            const freshEntity = new Entity(entity.id);
+            freshEntity.setPersisted(true);
+            ctx.tracker.track(freshEntity);
+
+            // First call loads from DB
+            await freshEntity.get(TestUser);
+            // Second call should use cache
+            expect(freshEntity.hasInMemory(TestUser)).toBe(true);
+        });
+    });
+
+    describe('getInstanceOf()', () => {
+        test('returns component instance', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Instance', email: 'instance@example.com', age: 28 });
+            await entity.save();
+
+            const user = await entity.getInstanceOf(TestUser);
+
+            expect(user).not.toBeNull();
+            expect(user).toBeInstanceOf(TestUser);
+            expect(user?.name).toBe('Instance');
+        });
+    });
+
+    describe('LoadMultiple()', () => {
+        test('loads multiple entities at once', async () => {
+            const entity1 = ctx.tracker.create();
+            entity1.add(TestUser, { name: 'User1', email: 'user1@example.com', age: 20 });
+            await entity1.save();
+
+            const entity2 = ctx.tracker.create();
+            entity2.add(TestUser, { name: 'User2', email: 'user2@example.com', age: 25 });
+            await entity2.save();
+
+            const loaded = await Entity.LoadMultiple([entity1.id, entity2.id]);
+
+            expect(loaded.length).toBe(2);
+        });
+
+        test('returns empty array for empty input', async () => {
+            const loaded = await Entity.LoadMultiple([]);
+            expect(loaded).toEqual([]);
+        });
+
+        test('filters out invalid IDs', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Valid', email: 'valid@example.com', age: 30 });
+            await entity.save();
+
+            const loaded = await Entity.LoadMultiple([entity.id, '', '  ']);
+            expect(loaded.length).toBe(1);
+        });
+    });
+
+    describe('Clone()', () => {
+        test('creates deep clone of entity', async () => {
+            const original = ctx.tracker.create();
+            original.add(TestUser, { name: 'Original', email: 'original@example.com', age: 30 });
+            await original.save();
+
+            const clone = Entity.Clone(original);
+            ctx.tracker.track(clone);
+
+            expect(clone.id).not.toBe(original.id);
+            expect(clone._persisted).toBe(false);
+            expect(clone.getInMemory(TestUser)?.name).toBe('Original');
+        });
+
+        test('cloned entity can be saved independently', async () => {
+            const original = ctx.tracker.create();
+            original.add(TestUser, { name: 'ToClone', email: 'clone@example.com', age: 25 });
+            await original.save();
+
+            const clone = Entity.Clone(original);
+            ctx.tracker.track(clone);
+            await clone.save();
+
+            expect(clone._persisted).toBe(true);
+
+            const loadedClone = await Entity.FindById(clone.id);
+            expect(loadedClone).not.toBeNull();
+        });
+    });
+
+    describe('component removal', () => {
+        test('remove() deletes component on save', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Remove', email: 'remove@example.com', age: 30 });
+            entity.add(TestProduct, { sku: 'REM', name: 'Remove Product', price: 10, inStock: true });
+            await entity.save();
+
+            entity.remove(TestProduct);
+            await entity.save();
+
+            // Load entity - only query with TestUser since TestProduct was removed
+            // If we query with both, the entity won't be returned (requires both components)
+            const results = await new Query().findById(entity.id).with(TestUser).populate().exec();
+            const loaded = results[0];
+
+            expect(loaded).toBeDefined();
+            expect(loaded?.hasInMemory(TestUser)).toBe(true);
+
+            // Verify TestProduct was actually removed from database
+            const productData = await loaded?.get(TestProduct);
+            expect(productData).toBeNull();
+        });
+    });
+
+    describe('serialize / deserialize roundtrip', () => {
+        test('entity can be serialized and deserialized', async () => {
+            const entity = ctx.tracker.create();
+            entity.add(TestUser, { name: 'Serialize', email: 'serialize@example.com', age: 35 });
+            await entity.save();
+
+            const serialized = entity.serialize();
+            const deserialized = Entity.deserialize(serialized);
+
+            expect(deserialized.id).toBe(entity.id);
+            expect(deserialized.getInMemory(TestUser)?.name).toBe('Serialize');
+        });
+    });
+});