bunsane 0.3.2 → 0.4.0

package/tests/integration/query/Query.exec.test.ts

@@ -1,576 +0,0 @@
-/**
- * Integration tests for Query execution
- * Tests query execution against the database
- */
-import { describe, test, expect, beforeAll, beforeEach, afterEach } from 'bun:test';
-import { Entity } from '../../../core/Entity';
-import { Query, FilterOp } from '../../../query/Query';
-import { TestUser, TestProduct, TestOrder } from '../../fixtures/components';
-import { createTestContext, ensureComponentsRegistered } from '../../utils';
-
-describe('Query Execution', () => {
-    const ctx = createTestContext();
-
-    beforeAll(async () => {
-        await ensureComponentsRegistered(TestUser, TestProduct, TestOrder);
-    });
-
-    describe('basic query execution', () => {
-        test('exec() returns only entities with specified component', async () => {
-            // Positive case: entity WITH TestUser component
-            const withUser = ctx.tracker.create();
-            withUser.add(TestUser, { name: 'QueryTest', email: 'query@example.com', age: 30 });
-            await withUser.save();
-
-            // Negative case: entity WITHOUT TestUser component (only has TestProduct)
-            const withoutUser = ctx.tracker.create();
-            withoutUser.add(TestProduct, { sku: 'NO_USER', name: 'No User Product', price: 10, inStock: true });
-            await withoutUser.save();
-
-            const results = await new Query()
-                .with(TestUser)
-                .exec();
-
-            // Positive: entity with TestUser should be found
-            const foundWithUser = results.some(e => e.id === withUser.id);
-            expect(foundWithUser).toBe(true);
-
-            // Negative: entity without TestUser should NOT be found
-            const foundWithoutUser = results.some(e => e.id === withoutUser.id);
-            expect(foundWithoutUser).toBe(false);
-        });
-
-        test('populate() loads all component data', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'PopulateTest', email: 'populate@example.com', age: 25 });
-            await entity.save();
-
-            const results = await new Query()
-                .with(TestUser)
-                .populate()
-                .exec();
-
-            const found = results.find(e => e.id === entity.id);
-            expect(found).toBeDefined();
-            expect(found?.getInMemory(TestUser)).toBeDefined();
-        });
-
-        test('returns empty array when no matches', async () => {
-            // Query for entities with a unique component
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('email', FilterOp.EQ, 'definitely-does-not-exist@nowhere.com')]
-                })
-                .exec();
-
-            expect(results.length).toBe(0);
-        });
-    });
-
-    describe('findById()', () => {
-        test('finds entity by ID', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'FindById', email: 'findby@example.com', age: 35 });
-            await entity.save();
-
-            const results = await new Query()
-                .findById(entity.id)
-                .exec();
-
-            expect(results.length).toBe(1);
-            expect(results[0]!.id).toBe(entity.id);
-        });
-
-        test('findOneById returns single entity', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'FindOne', email: 'findone@example.com', age: 40 });
-            await entity.save();
-
-            const result = await new Query().findOneById(entity.id);
-
-            expect(result).not.toBeNull();
-            expect(result?.id).toBe(entity.id);
-        });
-
-        test('findOneById returns null for non-existent ID', async () => {
-            const result = await new Query().findOneById('00000000-0000-0000-0000-000000000000');
-            expect(result).toBeNull();
-        });
-    });
-
-    describe('filtering', () => {
-        beforeEach(async () => {
-            // Create test data
-            const entity1 = ctx.tracker.create();
-            entity1.add(TestUser, { name: 'Alice', email: 'alice@example.com', age: 25 });
-            await entity1.save();
-
-            const entity2 = ctx.tracker.create();
-            entity2.add(TestUser, { name: 'Bob', email: 'bob@example.com', age: 35 });
-            await entity2.save();
-
-            const entity3 = ctx.tracker.create();
-            entity3.add(TestUser, { name: 'Charlie', email: 'charlie@example.com', age: 45 });
-            await entity3.save();
-        });
-
-        test('EQ filter finds exact match', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('name', FilterOp.EQ, 'Alice')]
-                })
-                .populate()
-                .exec();
-
-            const alice = results.find(e => e.getInMemory(TestUser)?.name === 'Alice');
-            expect(alice).toBeDefined();
-        });
-
-        test('GT filter finds greater values', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('age', FilterOp.GT, 30)]
-                })
-                .populate()
-                .exec();
-
-            for (const entity of results) {
-                const user = entity.getInMemory(TestUser);
-                if (user) {
-                    expect(user.age).toBeGreaterThan(30);
-                }
-            }
-        });
-
-        test('LT filter finds lesser values', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('age', FilterOp.LT, 40)]
-                })
-                .populate()
-                .exec();
-
-            for (const entity of results) {
-                const user = entity.getInMemory(TestUser);
-                if (user) {
-                    expect(user.age).toBeLessThan(40);
-                }
-            }
-        });
-
-        test('LIKE filter finds partial matches', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('email', FilterOp.LIKE, '%example.com')]
-                })
-                .populate()
-                .exec();
-
-            expect(results.length).toBeGreaterThanOrEqual(1);
-        });
-    });
-
-    describe('pagination', () => {
-        beforeEach(async () => {
-            // Create multiple entities for pagination
-            for (let i = 0; i < 5; i++) {
-                const entity = ctx.tracker.create();
-                entity.add(TestUser, {
-                    name: `PaginationUser${i}`,
-                    email: `page${i}@example.com`,
-                    age: 20 + i
-                });
-                await entity.save();
-            }
-        });
-
-        test('take() limits results', async () => {
-            const results = await new Query()
-                .with(TestUser)
-                .take(2)
-                .exec();
-
-            expect(results.length).toBeLessThanOrEqual(2);
-        });
-
-        test('offset() skips results', async () => {
-            const allResults = await new Query()
-                .with(TestUser)
-                .exec();
-
-            const offsetResults = await new Query()
-                .with(TestUser)
-                .offset(2)
-                .take(100)
-                .exec();
-
-            expect(offsetResults.length).toBe(Math.max(0, allResults.length - 2));
-        });
-
-        test('take() and offset() work together', async () => {
-            const results = await new Query()
-                .with(TestUser)
-                .take(2)
-                .offset(1)
-                .exec();
-
-            expect(results.length).toBeLessThanOrEqual(2);
-        });
-    });
-
-    describe('sorting', () => {
-        beforeEach(async () => {
-            const ages = [30, 20, 40, 25, 35];
-            for (let i = 0; i < ages.length; i++) {
-                const entity = ctx.tracker.create();
-                entity.add(TestUser, {
-                    name: `SortUser${i}`,
-                    email: `sort${i}@example.com`,
-                    age: ages[i]!
-                });
-                await entity.save();
-            }
-        });
-
-        test('sortBy ASC orders correctly', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('email', FilterOp.LIKE, 'sort%@example.com')]
-                })
-                .sortBy(TestUser, 'age', 'ASC')
-                .populate()
-                .exec();
-
-            for (let i = 1; i < results.length; i++) {
-                const prevAge = results[i - 1]!.getInMemory(TestUser)?.age ?? 0;
-                const currAge = results[i]!.getInMemory(TestUser)?.age ?? 0;
-                expect(currAge).toBeGreaterThanOrEqual(prevAge);
-            }
-        });
-
-        test('sortBy DESC orders correctly', async () => {
-            const results = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('email', FilterOp.LIKE, 'sort%@example.com')]
-                })
-                .sortBy(TestUser, 'age', 'DESC')
-                .populate()
-                .exec();
-
-            for (let i = 1; i < results.length; i++) {
-                const prevAge = results[i - 1]!.getInMemory(TestUser)?.age ?? 0;
-                const currAge = results[i]!.getInMemory(TestUser)?.age ?? 0;
-                expect(currAge).toBeLessThanOrEqual(prevAge);
-            }
-        });
-    });
-
-    describe('count()', () => {
-        test('returns count of matching entities', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'CountTest', email: 'count@example.com', age: 30 });
-            await entity.save();
-
-            const count = await new Query()
-                .with(TestUser)
-                .count();
-
-            expect(count).toBeGreaterThanOrEqual(1);
-        });
-
-        test('count respects filters', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'UniqueCountName', email: 'uniquecount@example.com', age: 99 });
-            await entity.save();
-
-            const count = await new Query()
-                .with(TestUser, {
-                    filters: [Query.filter('name', FilterOp.EQ, 'UniqueCountName')]
-                })
-                .count();
-
-            expect(count).toBe(1);
-        });
-    });
-
-    describe('multiple components', () => {
-        test('with() multiple components finds only entities with ALL components', async () => {
-            // Positive case: entity with BOTH TestUser AND TestProduct
-            const withBoth = ctx.tracker.create();
-            withBoth.add(TestUser, { name: 'MultiComp', email: 'multi@example.com', age: 30 });
-            withBoth.add(TestProduct, { sku: 'MULTI', name: 'Multi Product', price: 50, inStock: true });
-            await withBoth.save();
-
-            // Negative case: entity with ONLY TestUser (missing TestProduct)
-            const withOnlyUser = ctx.tracker.create();
-            withOnlyUser.add(TestUser, { name: 'OnlyUser', email: 'onlyuser@example.com', age: 25 });
-            await withOnlyUser.save();
-
-            const results = await new Query()
-                .with(TestUser)
-                .with(TestProduct)
-                .populate()
-                .exec();
-
-            // Positive: entity with both components should be found
-            const foundWithBoth = results.find(e => e.id === withBoth.id);
-            expect(foundWithBoth).toBeDefined();
-            expect(foundWithBoth?.getInMemory(TestUser)).toBeDefined();
-            expect(foundWithBoth?.getInMemory(TestProduct)).toBeDefined();
-
-            // Negative: entity with only one component should NOT be found
-            const foundWithOnlyUser = results.some(e => e.id === withOnlyUser.id);
-            expect(foundWithOnlyUser).toBe(false);
-        });
-
-        test('without() excludes entities with component', async () => {
-            const withProduct = ctx.tracker.create();
-            withProduct.add(TestUser, { name: 'WithProduct', email: 'withprod@example.com', age: 25 });
-            withProduct.add(TestProduct, { sku: 'WITH', name: 'With', price: 10, inStock: true });
-            await withProduct.save();
-
-            const withoutProduct = ctx.tracker.create();
-            withoutProduct.add(TestUser, { name: 'WithoutProduct', email: 'withoutprod@example.com', age: 30 });
-            await withoutProduct.save();
-
-            const results = await new Query()
-                .with(TestUser)
-                .without(TestProduct)
-                .exec();
-
-            const hasWithProduct = results.some(e => e.id === withProduct.id);
-            expect(hasWithProduct).toBe(false);
-        });
-
-        test('with() 3+ components without filters finds entities with ALL components', async () => {
-            // Positive case: entity with ALL 3 components
-            const withAll = ctx.tracker.create();
-            withAll.add(TestUser, { name: 'AllThree', email: 'allthree@example.com', age: 30 });
-            withAll.add(TestProduct, { sku: 'ALL3', name: 'All Three Product', price: 100, inStock: true });
-            withAll.add(TestOrder, { orderNumber: 'ORD-ALL3', total: 100, status: 'pending' });
-            await withAll.save();
-
-            // Negative case: entity with only 2 of 3 components (missing TestOrder)
-            const withTwo = ctx.tracker.create();
-            withTwo.add(TestUser, { name: 'TwoOnly', email: 'twoonly@example.com', age: 25 });
-            withTwo.add(TestProduct, { sku: 'TWO', name: 'Two Only Product', price: 50, inStock: true });
-            await withTwo.save();
-
-            // Query for entities with all 3 components - NO FILTERS
-            const results = await new Query()
-                .with(TestUser)
-                .with(TestProduct)
-                .with(TestOrder)
-                .exec();
-
-            // Positive: entity with all 3 components should be found
-            const foundWithAll = results.some(e => e.id === withAll.id);
-            expect(foundWithAll).toBe(true);
-
-            // Negative: entity with only 2 components should NOT be found
-            const foundWithTwo = results.some(e => e.id === withTwo.id);
-            expect(foundWithTwo).toBe(false);
-        });
-    });
-
-    describe('excludeEntityId()', () => {
-        test('excludes specific entity from results', async () => {
-            const entity1 = ctx.tracker.create();
-            entity1.add(TestUser, { name: 'Include', email: 'include@example.com', age: 30 });
-            await entity1.save();
-
-            const entity2 = ctx.tracker.create();
-            entity2.add(TestUser, { name: 'Exclude', email: 'exclude@example.com', age: 30 });
-            await entity2.save();
-
-            const results = await new Query()
-                .with(TestUser)
-                .excludeEntityId(entity2.id)
-                .exec();
-
-            const hasExcluded = results.some(e => e.id === entity2.id);
-            expect(hasExcluded).toBe(false);
-        });
-    });
-
-    describe('eagerLoadComponents()', () => {
-        test('preloads specified components', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'Eager', email: 'eager@example.com', age: 30 });
-            entity.add(TestProduct, { sku: 'EAGER', name: 'Eager Product', price: 20, inStock: true });
-            await entity.save();
-
-            const results = await new Query()
-                .with(TestUser)
-                .eagerLoadComponents([TestProduct])
-                .exec();
-
-            const found = results.find(e => e.id === entity.id);
-            expect(found?.hasInMemory(TestProduct)).toBe(true);
-        });
-    });
-
-    describe('sum()', () => {
-        test('returns correct sum of numeric field', async () => {
-            // Create entities with known prices
-            const prices = [10, 20, 30, 40];
-            const expectedSum = prices.reduce((a, b) => a + b, 0); // 100
-
-            for (let i = 0; i < prices.length; i++) {
-                const entity = ctx.tracker.create();
-                entity.add(TestProduct, {
-                    sku: `SUM_TEST_${i}_${Date.now()}`,
-                    name: `Sum Product ${i}`,
-                    price: prices[i]!,
-                    inStock: true
-                });
-                await entity.save();
-            }
-
-            const sum = await new Query()
-                .with(TestProduct, {
-                    filters: [Query.filter('sku', FilterOp.LIKE, 'SUM_TEST_%')]
-                })
-                .sum(TestProduct, 'price');
-
-            expect(sum).toBe(expectedSum);
-        });
-
-        test('returns 0 when no entities match', async () => {
-            const sum = await new Query()
-                .with(TestProduct, {
-                    filters: [Query.filter('sku', FilterOp.EQ, 'NONEXISTENT_SKU_12345')]
-                })
-                .sum(TestProduct, 'price');
-
-            expect(sum).toBe(0);
-        });
-
-        test('sum works with filters', async () => {
-            // Create entities - some in stock, some not
-            const entity1 = ctx.tracker.create();
-            entity1.add(TestProduct, {
-                sku: `SUM_FILTER_1_${Date.now()}`,
-                name: 'In Stock',
-                price: 50,
-                inStock: true
-            });
-            await entity1.save();
-
-            const entity2 = ctx.tracker.create();
-            entity2.add(TestProduct, {
-                sku: `SUM_FILTER_2_${Date.now()}`,
-                name: 'Out of Stock',
-                price: 100,
-                inStock: false
-            });
-            await entity2.save();
-
-            // Sum only in-stock items
-            const sum = await new Query()
-                .with(TestProduct, {
-                    filters: [
-                        Query.filter('sku', FilterOp.LIKE, 'SUM_FILTER_%'),
-                        Query.filter('inStock', FilterOp.EQ, true)
-                    ]
-                })
-                .sum(TestProduct, 'price');
-
-            expect(sum).toBe(50);
-        });
-    });
-
-    describe('average()', () => {
-        test('returns correct average of numeric field', async () => {
-            // Create entities with known prices
-            const prices = [10, 20, 30, 40];
-            const expectedAvg = prices.reduce((a, b) => a + b, 0) / prices.length; // 25
-
-            for (let i = 0; i < prices.length; i++) {
-                const entity = ctx.tracker.create();
-                entity.add(TestProduct, {
-                    sku: `AVG_TEST_${i}_${Date.now()}`,
-                    name: `Avg Product ${i}`,
-                    price: prices[i]!,
-                    inStock: true
-                });
-                await entity.save();
-            }
-
-            const avg = await new Query()
-                .with(TestProduct, {
-                    filters: [Query.filter('sku', FilterOp.LIKE, 'AVG_TEST_%')]
-                })
-                .average(TestProduct, 'price');
-
-            expect(avg).toBe(expectedAvg);
-        });
-
-        test('returns 0 when no entities match', async () => {
-            const avg = await new Query()
-                .with(TestProduct, {
-                    filters: [Query.filter('sku', FilterOp.EQ, 'NONEXISTENT_SKU_67890')]
-                })
-                .average(TestProduct, 'price');
-
-            expect(avg).toBe(0);
-        });
-
-        test('average handles decimal results', async () => {
-            // Create entities with prices that result in decimal average
-            const prices = [10, 20, 30]; // avg = 20
-
-            for (let i = 0; i < prices.length; i++) {
-                const entity = ctx.tracker.create();
-                entity.add(TestProduct, {
-                    sku: `AVG_DEC_${i}_${Date.now()}`,
-                    name: `Decimal Avg ${i}`,
-                    price: prices[i]!,
-                    inStock: true
-                });
-                await entity.save();
-            }
-
-            const avg = await new Query()
-                .with(TestProduct, {
-                    filters: [Query.filter('sku', FilterOp.LIKE, 'AVG_DEC_%')]
-                })
-                .average(TestProduct, 'price');
-
-            expect(avg).toBe(20);
-        });
-
-        test('average works with filters', async () => {
-            // Create entities - some expensive, some cheap
-            const entity1 = ctx.tracker.create();
-            entity1.add(TestProduct, {
-                sku: `AVG_FILTER_CHEAP_${Date.now()}`,
-                name: 'Cheap Product',
-                price: 10,
-                inStock: true
-            });
-            await entity1.save();
-
-            const entity2 = ctx.tracker.create();
-            entity2.add(TestProduct, {
-                sku: `AVG_FILTER_EXPENSIVE_${Date.now()}`,
-                name: 'Expensive Product',
-                price: 1000,
-                inStock: true
-            });
-            await entity2.save();
-
-            // Average only cheap items (price < 100)
-            const avg = await new Query()
-                .with(TestProduct, {
-                    filters: [
-                        Query.filter('sku', FilterOp.LIKE, 'AVG_FILTER_%'),
-                        Query.filter('price', FilterOp.LT, 100)
-                    ]
-                })
-                .average(TestProduct, 'price');
-
-            expect(avg).toBe(10);
-        });
-    });
-});