bunsane 0.1.4 → 0.2.0

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

@@ -0,0 +1,411 @@
+/**
+ * Unit tests for RedisCache
+ * Tests Redis cache provider functionality with a real Redis server
+ *
+ * PREREQUISITE: Redis server must be running on localhost:6379
+ */
+import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
+import { RedisCache } from '../../../core/cache/RedisCache';
+
+describe('RedisCache', () => {
+    let cache: RedisCache;
+    const TEST_PREFIX = 'bunsane:test:';
+
+    beforeAll(async () => {
+        cache = new RedisCache({
+            host: 'localhost',
+            port: 6379,
+            keyPrefix: TEST_PREFIX,
+            lazyConnect: false,
+            enableReadyCheck: true,
+            maxRetriesPerRequest: 3
+        });
+
+        // Wait for connection
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Verify connection
+        const isConnected = await cache.ping();
+        if (!isConnected) {
+            throw new Error('Failed to connect to Redis. Make sure Redis server is running on localhost:6379');
+        }
+    });
+
+    afterAll(async () => {
+        // Clean up test keys before disconnecting
+        await cache.invalidatePattern('*');
+        await cache.disconnect();
+    });
+
+    beforeEach(async () => {
+        // Clear test keys before each test
+        await cache.invalidatePattern('*');
+    });
+
+    describe('ping()', () => {
+        test('returns true when connected', async () => {
+            const result = await cache.ping();
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('healthCheck()', () => {
+        test('returns health status with connection info', async () => {
+            const health = await cache.healthCheck();
+
+            expect(health.connected).toBe(true);
+            expect(typeof health.latency).toBe('number');
+            expect(health.latency).toBeGreaterThanOrEqual(0);
+            expect(health.version).toBeDefined();
+        });
+    });
+
+    describe('get() and set()', () => {
+        test('returns null for non-existent key', async () => {
+            const result = await cache.get('non-existent-key');
+            expect(result).toBeNull();
+        });
+
+        test('sets and retrieves string value', async () => {
+            await cache.set('string-key', 'hello world', 3600000);
+            const result = await cache.get<string>('string-key');
+            expect(result).toBe('hello world');
+        });
+
+        test('sets and retrieves number value', async () => {
+            await cache.set('number-key', 42, 3600000);
+            const result = await cache.get<number>('number-key');
+            expect(result).toBe(42);
+        });
+
+        test('sets and retrieves object', async () => {
+            const obj = { name: 'test', value: 123, nested: { a: 1, b: 2 } };
+            await cache.set('obj-key', obj, 3600000);
+            const result = await cache.get<typeof obj>('obj-key');
+            expect(result).toEqual(obj);
+        });
+
+        test('sets and retrieves array', async () => {
+            const arr = [1, 2, 3, 'four', { five: 5 }];
+            await cache.set('arr-key', arr, 3600000);
+            const result = await cache.get<typeof arr>('arr-key');
+            expect(result).toEqual(arr);
+        });
+
+        test('sets and retrieves boolean values', async () => {
+            await cache.set('bool-true', true, 3600000);
+            await cache.set('bool-false', false, 3600000);
+
+            expect(await cache.get<boolean>('bool-true')).toBe(true);
+            expect(await cache.get<boolean>('bool-false')).toBe(false);
+        });
+
+        test('sets and retrieves null value', async () => {
+            await cache.set('null-key', null, 3600000);
+            const result = await cache.get('null-key');
+            expect(result).toBeNull();
+        });
+
+        test('expires after TTL', async () => {
+            // Redis TTL is in seconds (minimum 1 second), our API uses milliseconds
+            await cache.set('expire-key', 'value', 1000); // 1 second TTL
+
+            const immediate = await cache.get('expire-key');
+            expect(immediate).toBe('value');
+
+            await new Promise(resolve => setTimeout(resolve, 1500));
+
+            const expired = await cache.get('expire-key');
+            expect(expired).toBeNull();
+        });
+
+        test('overwrites existing key', async () => {
+            await cache.set('overwrite-key', 'original', 3600000);
+            await cache.set('overwrite-key', 'updated', 3600000);
+
+            const result = await cache.get('overwrite-key');
+            expect(result).toBe('updated');
+        });
+    });
+
+    describe('delete()', () => {
+        test('removes single key', async () => {
+            await cache.set('delete-key', 'value', 3600000);
+            await cache.delete('delete-key');
+
+            const result = await cache.get('delete-key');
+            expect(result).toBeNull();
+        });
+
+        test('removes multiple keys via array', async () => {
+            await cache.set('del-key1', 'value1', 3600000);
+            await cache.set('del-key2', 'value2', 3600000);
+            await cache.delete(['del-key1', 'del-key2']);
+
+            expect(await cache.get('del-key1')).toBeNull();
+            expect(await cache.get('del-key2')).toBeNull();
+        });
+
+        test('handles non-existent key gracefully', async () => {
+            // Should not throw and key should remain absent
+            await cache.delete('definitely-not-exists');
+            const result = await cache.get('definitely-not-exists');
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('deleteMany()', () => {
+        test('removes multiple keys', async () => {
+            await cache.set('dm-a', 1, 3600000);
+            await cache.set('dm-b', 2, 3600000);
+            await cache.set('dm-c', 3, 3600000);
+
+            await cache.deleteMany(['dm-a', 'dm-b']);
+
+            expect(await cache.get('dm-a')).toBeNull();
+            expect(await cache.get('dm-b')).toBeNull();
+            expect(await cache.get<number>('dm-c')).toBe(3);
+        });
+
+        test('handles empty array', async () => {
+            // Set a key first, then deleteMany([]) should not affect it
+            await cache.set('survive-key', 'value', 3600000);
+            await cache.deleteMany([]);
+            const result = await cache.get<string>('survive-key');
+            expect(result).toBe('value');
+        });
+    });
+
+    describe('getMany()', () => {
+        test('returns array of values in order', async () => {
+            await cache.set('gm-k1', 'v1', 3600000);
+            await cache.set('gm-k2', 'v2', 3600000);
+            await cache.set('gm-k3', 'v3', 3600000);
+
+            const results = await cache.getMany(['gm-k1', 'gm-k2', 'gm-k3']);
+
+            expect(results).toEqual(['v1', 'v2', 'v3']);
+        });
+
+        test('returns null for missing keys', async () => {
+            await cache.set('gm-exists', 'value', 3600000);
+
+            const results = await cache.getMany(['gm-exists', 'gm-missing', 'gm-also-missing']);
+
+            expect(results[0]).toBe('value');
+            expect(results[1]).toBeNull();
+            expect(results[2]).toBeNull();
+        });
+
+        test('handles empty array', async () => {
+            const results = await cache.getMany([]);
+            expect(results).toEqual([]);
+        });
+    });
+
+    describe('setMany()', () => {
+        test('sets multiple entries', async () => {
+            await cache.setMany([
+                { key: 'sm-a', value: 1, ttl: 3600000 },
+                { key: 'sm-b', value: 2, ttl: 3600000 },
+                { key: 'sm-c', value: 3, ttl: 3600000 }
+            ]);
+
+            expect(await cache.get<number>('sm-a')).toBe(1);
+            expect(await cache.get<number>('sm-b')).toBe(2);
+            expect(await cache.get<number>('sm-c')).toBe(3);
+        });
+
+        test('sets entries with different TTLs', async () => {
+            // Redis TTL minimum is 1 second
+            await cache.setMany([
+                { key: 'sm-short', value: 'short-lived', ttl: 1000 }, // 1 second
+                { key: 'sm-long', value: 'long-lived', ttl: 3600000 }
+            ]);
+
+            // Both should exist initially
+            expect(await cache.get<string>('sm-short')).toBe('short-lived');
+            expect(await cache.get<string>('sm-long')).toBe('long-lived');
+
+            // Wait for short TTL to expire
+            await new Promise(resolve => setTimeout(resolve, 1500));
+
+            expect(await cache.get('sm-short')).toBeNull();
+            expect(await cache.get<string>('sm-long')).toBe('long-lived');
+        });
+
+        test('handles empty array', async () => {
+            // setMany([]) should be a no-op, existing keys unaffected
+            await cache.set('survive-set', 'value', 3600000);
+            await cache.setMany([]);
+            const result = await cache.get<string>('survive-set');
+            expect(result).toBe('value');
+        });
+    });
+
+    describe('clear()', () => {
+        test('removes all entries with prefix', async () => {
+            await cache.set('clear-key1', 'value1', 3600000);
+            await cache.set('clear-key2', 'value2', 3600000);
+
+            await cache.clear();
+
+            expect(await cache.get('clear-key1')).toBeNull();
+            expect(await cache.get('clear-key2')).toBeNull();
+        });
+    });
+
+    describe('invalidatePattern()', () => {
+        test('removes keys matching simple prefix pattern', async () => {
+            await cache.set('prefix:1', 'v1', 3600000);
+            await cache.set('prefix:2', 'v2', 3600000);
+            await cache.set('other:1', 'o1', 3600000);
+
+            await cache.invalidatePattern('prefix:*');
+
+            expect(await cache.get('prefix:1')).toBeNull();
+            expect(await cache.get('prefix:2')).toBeNull();
+            expect(await cache.get<string>('other:1')).toBe('o1');
+        });
+
+        test('handles complex patterns', async () => {
+            await cache.set('component:entity1:type1', 'c1', 3600000);
+            await cache.set('component:entity1:type2', 'c2', 3600000);
+            await cache.set('component:entity2:type1', 'c3', 3600000);
+
+            await cache.invalidatePattern('component:entity1:*');
+
+            expect(await cache.get('component:entity1:type1')).toBeNull();
+            expect(await cache.get('component:entity1:type2')).toBeNull();
+            expect(await cache.get<string>('component:entity2:type1')).toBe('c3');
+        });
+
+        test('handles pattern with no matches', async () => {
+            await cache.set('keep-this', 'value', 3600000);
+
+            await cache.invalidatePattern('nomatch:*');
+
+            expect(await cache.get<string>('keep-this')).toBe('value');
+        });
+    });
+
+    describe('getStats()', () => {
+        test('returns statistics object', async () => {
+            // Perform some operations to generate stats
+            await cache.set('stats-key', 'value', 3600000);
+            await cache.get('stats-key'); // Hit
+            await cache.get('stats-missing'); // Miss
+
+            const stats = await cache.getStats();
+
+            expect(typeof stats.hits).toBe('number');
+            expect(typeof stats.misses).toBe('number');
+            expect(typeof stats.hitRate).toBe('number');
+            expect(typeof stats.size).toBe('number');
+            expect(stats.hits).toBeGreaterThanOrEqual(0);
+            expect(stats.misses).toBeGreaterThanOrEqual(0);
+        });
+
+        test('tracks hit rate correctly', async () => {
+            // Fresh stats after clear
+            await cache.set('hr-key', 'value', 3600000);
+
+            // Create predictable hits and misses
+            await cache.get('hr-key'); // Hit
+            await cache.get('hr-missing'); // Miss
+
+            const stats = await cache.getStats();
+
+            // Hit rate should be between 0 and 1
+            expect(stats.hitRate).toBeGreaterThanOrEqual(0);
+            expect(stats.hitRate).toBeLessThanOrEqual(1);
+        });
+    });
+
+    describe('complex data types', () => {
+        test('handles deeply nested objects', async () => {
+            const complex = {
+                level1: {
+                    level2: {
+                        level3: {
+                            value: 'deep',
+                            array: [1, 2, { nested: true }]
+                        }
+                    }
+                }
+            };
+
+            await cache.set('complex-obj', complex, 3600000);
+            const result = await cache.get<typeof complex>('complex-obj');
+
+            expect(result).toEqual(complex);
+        });
+
+        test('handles Date objects (serialized as string)', async () => {
+            const date = new Date('2024-01-15T10:30:00Z');
+            await cache.set('date-key', date, 3600000);
+
+            const result = await cache.get<string>('date-key');
+            // Date gets serialized to ISO string
+            expect(result).toBe(date.toISOString());
+        });
+
+        test('handles large arrays', async () => {
+            const largeArray = Array.from({ length: 1000 }, (_, i) => ({ id: i, value: `item-${i}` }));
+
+            await cache.set('large-array', largeArray, 3600000);
+            const result = await cache.get<typeof largeArray>('large-array');
+
+            expect(result).toEqual(largeArray);
+            expect(result?.length).toBe(1000);
+        });
+    });
+
+    describe('concurrent operations', () => {
+        test('handles concurrent sets', async () => {
+            const promises = Array.from({ length: 10 }, (_, i) =>
+                cache.set(`concurrent-${i}`, i, 3600000)
+            );
+
+            await Promise.all(promises);
+
+            for (let i = 0; i < 10; i++) {
+                const result = await cache.get<number>(`concurrent-${i}`);
+                expect(result).toBe(i);
+            }
+        });
+
+        test('handles concurrent gets', async () => {
+            await cache.set('concurrent-read', 'value', 3600000);
+
+            const promises = Array.from({ length: 10 }, () =>
+                cache.get<string>('concurrent-read')
+            );
+
+            const results = await Promise.all(promises);
+
+            results.forEach(result => {
+                expect(result).toBe('value');
+            });
+        });
+
+        test('handles mixed concurrent operations', async () => {
+            const operations = [
+                cache.set('mixed-1', 'a', 3600000),
+                cache.set('mixed-2', 'b', 3600000),
+                cache.set('mixed-3', 'c', 3600000),
+            ];
+
+            await Promise.all(operations);
+
+            const reads = [
+                cache.get('mixed-1'),
+                cache.get('mixed-2'),
+                cache.get('mixed-3'),
+            ];
+
+            const results = await Promise.all(reads);
+            expect(results).toEqual(['a', 'b', 'c']);
+        });
+    });
+});

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

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