bunsane 0.3.1 → 0.4.0

package/tests/unit/entity/Entity.components.test.ts

@@ -1,317 +0,0 @@
-/**
- * Unit tests for Entity component management
- * Tests component add, remove, and data handling
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
-import { ensureComponentsRegistered } from '../../utils';
-
-describe('Entity Component Management', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
-    });
-
-    describe('component data handling', () => {
-        test('component data() returns correct properties', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30, bio: 'A bio' });
-
-            const component = entity.getInMemory(TestUser);
-            const data = component?.data();
-
-            expect(data?.name).toBe('John');
-            expect(data?.email).toBe('john@test.com');
-            expect(data?.age).toBe(30);
-            expect(data?.bio).toBe('A bio');
-        });
-
-        test('component handles nullable fields', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-
-            const component = entity.getInMemory(TestUser);
-            const data = component?.data();
-
-            expect(data?.bio).toBeUndefined();
-        });
-
-        test('component handles boolean fields', () => {
-            const entity = new Entity();
-            entity.add(TestProduct, {
-                sku: 'SKU123',
-                name: 'Test Product',
-                price: 99.99,
-                inStock: true
-            });
-
-            const component = entity.getInMemory(TestProduct);
-            expect(component?.inStock).toBe(true);
-        });
-
-        test('component handles false boolean correctly', () => {
-            const entity = new Entity();
-            entity.add(TestProduct, {
-                sku: 'SKU123',
-                name: 'Test Product',
-                price: 99.99,
-                inStock: false
-            });
-
-            const component = entity.getInMemory(TestProduct);
-            expect(component?.inStock).toBe(false);
-        });
-
-        test('component handles number fields', () => {
-            const entity = new Entity();
-            entity.add(TestProduct, {
-                sku: 'SKU123',
-                name: 'Test Product',
-                price: 123.45,
-                inStock: true
-            });
-
-            const component = entity.getInMemory(TestProduct);
-            expect(component?.price).toBe(123.45);
-        });
-
-        test('component handles zero value correctly', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 0 });
-
-            const component = entity.getInMemory(TestUser);
-            expect(component?.age).toBe(0);
-        });
-
-        test('component handles Date fields', () => {
-            const date = new Date('2024-01-15T10:30:00Z');
-            const entity = new Entity();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-001',
-                total: 150.00,
-                status: 'pending',
-                createdAt: date
-            });
-
-            const component = entity.getInMemory(TestOrder);
-            expect(component?.createdAt).toEqual(date);
-        });
-    });
-
-    describe('multiple components', () => {
-        test('handles multiple components of different types', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-            entity.add(TestProduct, { sku: 'SKU1', name: 'Product 1', price: 50, inStock: true });
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-001',
-                total: 150,
-                status: 'completed',
-                createdAt: new Date()
-            });
-
-            expect(entity.componentList().length).toBe(3);
-            expect(entity.hasInMemory(TestUser)).toBe(true);
-            expect(entity.hasInMemory(TestProduct)).toBe(true);
-            expect(entity.hasInMemory(TestOrder)).toBe(true);
-        });
-
-        test('each component maintains its own data', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'User Name', email: 'user@test.com', age: 25 });
-            entity.add(TestProduct, { sku: 'PROD1', name: 'Product Name', price: 100, inStock: true });
-
-            const user = entity.getInMemory(TestUser);
-            const product = entity.getInMemory(TestProduct);
-
-            expect(user?.name).toBe('User Name');
-            expect(product?.name).toBe('Product Name');
-        });
-
-        test('removing one component does not affect others', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-            entity.add(TestProduct, { sku: 'SKU1', name: 'Product', price: 50, inStock: true });
-
-            entity.remove(TestUser);
-
-            expect(entity.hasInMemory(TestUser)).toBe(false);
-            expect(entity.hasInMemory(TestProduct)).toBe(true);
-            expect(entity.getInMemory(TestProduct)?.name).toBe('Product');
-        });
-    });
-
-    describe('component replacement', () => {
-        test('adding same component type replaces existing', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'Original', email: 'original@test.com', age: 30 });
-            entity.add(TestUser, { name: 'Replaced', email: 'replaced@test.com', age: 25 });
-
-            const components = entity.componentList();
-            expect(components.length).toBe(1);
-
-            const user = entity.getInMemory(TestUser);
-            expect(user?.name).toBe('Replaced');
-            expect(user?.email).toBe('replaced@test.com');
-        });
-    });
-
-    describe('component serialization', () => {
-        test('serializableData returns proper format', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-
-            const component = entity.getInMemory(TestUser);
-            const data = component?.serializableData();
-
-            expect(data).toEqual({
-                name: 'John',
-                email: 'john@test.com',
-                age: 30,
-                bio: undefined
-            });
-        });
-
-        test('serializableData handles Date as ISO string', () => {
-            const date = new Date('2024-01-15T10:30:00.000Z');
-            const entity = new Entity();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-001',
-                total: 100,
-                status: 'pending',
-                createdAt: date
-            });
-
-            const component = entity.getInMemory(TestOrder);
-            const data = component?.serializableData();
-
-            expect(data?.createdAt).toBe('2024-01-15T10:30:00.000Z');
-        });
-
-        test('serializableData throws descriptive error on invalid Date', () => {
-            const entity = new Entity();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-002',
-                total: 50,
-                status: 'pending',
-                createdAt: new Date('not-a-date')
-            });
-
-            const component = entity.getInMemory(TestOrder);
-            expect(() => component?.serializableData()).toThrow(
-                /Invalid Date for property 'createdAt' on component 'TestOrder'/
-            );
-        });
-
-        test('serializableData throws on Date type mismatch', () => {
-            const entity = new Entity();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-003',
-                total: 50,
-                status: 'pending',
-                createdAt: '2024-01-15' as any
-            });
-
-            const component = entity.getInMemory(TestOrder);
-            expect(() => component?.serializableData()).toThrow(
-                /Type mismatch for property 'createdAt' on component 'TestOrder': expected Date, got string/
-            );
-        });
-
-        test('serializableData throws on NaN number', () => {
-            const entity = new Entity();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-004',
-                total: NaN,
-                status: 'pending',
-                createdAt: new Date()
-            });
-
-            const component = entity.getInMemory(TestOrder);
-            expect(() => component?.serializableData()).toThrow(
-                /Invalid number for property 'total' on component 'TestOrder'/
-            );
-        });
-
-        test('serializableData throws on Infinity number', () => {
-            const entity = new Entity();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-005',
-                total: Infinity,
-                status: 'pending',
-                createdAt: new Date()
-            });
-
-            const component = entity.getInMemory(TestOrder);
-            expect(() => component?.serializableData()).toThrow(
-                /Invalid number for property 'total' on component 'TestOrder'/
-            );
-        });
-
-        test('serializableData allows null/undefined for nullable Date/Number', () => {
-            const entity = new Entity();
-            entity.add(TestOrder, {
-                orderNumber: 'ORD-006',
-                total: 0,
-                status: 'pending',
-                createdAt: null as any
-            });
-
-            const component = entity.getInMemory(TestOrder);
-            expect(() => component?.serializableData()).not.toThrow();
-        });
-    });
-
-    describe('component state', () => {
-        test('new component is not persisted', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-
-            const component = entity.getInMemory(TestUser);
-            expect((component as any)._persisted).toBe(false);
-        });
-
-        test('new component is dirty', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-
-            const component = entity.getInMemory(TestUser);
-            expect((component as any)._dirty).toBe(false); // Initial state from constructor
-        });
-
-        test('component has type ID', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-
-            const component = entity.getInMemory(TestUser);
-            expect(component?.getTypeID()).toBeDefined();
-            expect(component?.getTypeID().length).toBeGreaterThan(0);
-        });
-
-        test('component properties returns correct list', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-
-            const component = entity.getInMemory(TestUser);
-            const props = component?.properties();
-
-            expect(props).toContain('name');
-            expect(props).toContain('email');
-            expect(props).toContain('age');
-            expect(props).toContain('bio');
-        });
-
-        test('indexedProperties returns only indexed fields', () => {
-            const entity = new Entity();
-            entity.add(TestUser, { name: 'John', email: 'john@test.com', age: 30 });
-
-            const component = entity.getInMemory(TestUser);
-            const indexed = component?.indexedProperties();
-
-            expect(indexed).toContain('name');
-            expect(indexed).toContain('email');
-            expect(indexed).not.toContain('age');
-            expect(indexed).not.toContain('bio');
-        });
-    });
-});

package/tests/unit/entity/Entity.drainSideEffects.test.ts

@@ -1,51 +0,0 @@
-/**
- * BUNSANE-001 defensive harness: verify Entity.drainPendingSideEffects()
- * awaits post-commit work scheduled via queueMicrotask from save(), so
- * tests under PGlite can settle prior-file background work before
- * asserting against freshly-committed state.
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-import { ensureComponentsRegistered } from '../../utils';
-
-@Component
-class DrainMarker extends BaseComponent {
-    @CompData()
-    value: string = '';
-}
-
-describe('Entity.drainPendingSideEffects', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(DrainMarker);
-    });
-
-    test('no-op when nothing is pending', async () => {
-        await expect(Entity.drainPendingSideEffects(100)).resolves.toBeUndefined();
-    });
-
-    test('awaits post-commit side effects scheduled by save()', async () => {
-        const saved = Entity.Create();
-        saved.add(DrainMarker, { value: 'pending' });
-        await saved.save();
-
-        // runPostCommitSideEffects is queued as a microtask. drain() must
-        // settle it before returning.
-        await Entity.drainPendingSideEffects(2_000);
-
-        // A second drain is a no-op.
-        await Entity.drainPendingSideEffects(100);
-    });
-
-    test('bounded by timeout, returns even if drain exceeds it', async () => {
-        const saved = Entity.Create();
-        saved.add(DrainMarker, { value: 'bounded' });
-        await saved.save();
-
-        const start = Date.now();
-        await Entity.drainPendingSideEffects(1);
-        const elapsed = Date.now() - start;
-        expect(elapsed).toBeLessThan(500);
-    });
-});

package/tests/unit/entity/Entity.reload.test.ts

@@ -1,63 +0,0 @@
-/**
- * Unit tests for Entity.reload (BUNSANE-006).
- * Ensures in-memory component state is discarded and re-hydrated from DB.
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-import { ensureComponentsRegistered } from '../../utils';
-import db from '../../../database';
-
-@Component
-class ReloadStatus extends BaseComponent {
-    @CompData()
-    value: string = '';
-}
-
-describe('Entity.reload', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(ReloadStatus);
-    });
-
-    test('no-op on entity without a valid id', async () => {
-        const entity = new Entity('');
-        await expect(entity.reload()).resolves.toBe(entity);
-    });
-
-    test('refreshes in-memory data after raw-SQL write', async () => {
-        const saved = Entity.Create();
-        saved.add(ReloadStatus, { value: 'before' });
-        await saved.save();
-
-        const typeId = new ReloadStatus().getTypeID();
-
-        // Write new value via raw SQL — bypasses entity cache invalidation.
-        await db.unsafe(
-            `UPDATE components SET data = data || '{"value":"after"}'::jsonb
-             WHERE entity_id = $1 AND type_id = $2`,
-            [saved.id, typeId]
-        );
-
-        // In-memory copy still holds stale value.
-        expect(saved.getInMemory(ReloadStatus)?.value).toBe('before');
-
-        const returned = await saved.reload();
-        expect(returned).toBe(saved);
-        expect(saved.getInMemory(ReloadStatus)?.value).toBe('after');
-    });
-
-    test('hydrates a bare Entity instance from DB', async () => {
-        const saved = Entity.Create();
-        saved.add(ReloadStatus, { value: 'hydrated' });
-        await saved.save();
-
-        const bare = new Entity(saved.id);
-        expect(bare.componentList().length).toBe(0);
-
-        await bare.reload();
-
-        expect(bare.hasInMemory(ReloadStatus)).toBe(true);
-        expect(bare.getInMemory(ReloadStatus)?.value).toBe('hydrated');
-    });
-});

package/tests/unit/entity/Entity.requireComponents.test.ts

@@ -1,72 +0,0 @@
-/**
- * Unit tests for Entity.requireComponents (BUNSANE-003).
- * Ensures ComponentTargetHook includeComponents matching sees tag
- * components that weren't eagerly loaded.
- */
-import { describe, test, expect, beforeAll } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { BaseComponent } from '../../../core/components/BaseComponent';
-import { Component, CompData } from '../../../core/components/Decorators';
-import { TestUser } from '../../fixtures/components';
-import { ensureComponentsRegistered } from '../../utils';
-
-@Component
-class ReqTag extends BaseComponent {}
-
-@Component
-class ReqData extends BaseComponent {
-    @CompData()
-    value: string = '';
-}
-
-describe('Entity.requireComponents', () => {
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, ReqTag, ReqData);
-    });
-
-    test('no-op for empty list', async () => {
-        const entity = Entity.Create();
-        await expect(entity.requireComponents([])).resolves.toBeUndefined();
-        expect(entity.componentList().length).toBe(0);
-    });
-
-    test('does nothing when components already in memory', async () => {
-        const entity = Entity.Create();
-        entity.add(ReqTag);
-        const before = entity.componentList().length;
-        await entity.requireComponents([ReqTag]);
-        expect(entity.componentList().length).toBe(before);
-    });
-
-    test('hydrates missing components from DB after save', async () => {
-        const saved = Entity.Create();
-        saved.add(ReqTag);
-        saved.add(ReqData, { value: 'hello' });
-        await saved.save();
-
-        const loaded = new Entity(saved.id);
-        expect(loaded.componentList().length).toBe(0);
-
-        await loaded.requireComponents([ReqTag, ReqData]);
-
-        expect(loaded.hasInMemory(ReqTag)).toBe(true);
-        expect(loaded.hasInMemory(ReqData)).toBe(true);
-        expect(loaded.getInMemory(ReqData)?.value).toBe('hello');
-    });
-
-    test('only fetches missing components, not already-loaded ones', async () => {
-        const saved = Entity.Create();
-        saved.add(ReqTag);
-        saved.add(ReqData, { value: 'mix' });
-        await saved.save();
-
-        const loaded = new Entity(saved.id);
-        await loaded.requireComponents([ReqData]);
-        expect(loaded.hasInMemory(ReqData)).toBe(true);
-        expect(loaded.hasInMemory(ReqTag)).toBe(false);
-
-        await loaded.requireComponents([ReqTag, ReqData]);
-        expect(loaded.hasInMemory(ReqTag)).toBe(true);
-        expect(loaded.getInMemory(ReqData)?.value).toBe('mix');
-    });
-});