bunsane 0.2.8 → 0.2.10

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

@@ -16,16 +16,28 @@ describe('Query Execution', () => {
     });
 
     describe('basic query execution', () => {
-        test('exec() returns entities with specified component', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'QueryTest', email: 'query@example.com', age: 30 });
-            await entity.save();
+        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();
 
-            expect(results.length).toBeGreaterThanOrEqual(1);
+            // 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 () => {
@@ -282,11 +294,17 @@ describe('Query Execution', () => {
     });
 
     describe('multiple components', () => {
-        test('with() multiple components finds entities with all', async () => {
-            const entity = ctx.tracker.create();
-            entity.add(TestUser, { name: 'MultiComp', email: 'multi@example.com', age: 30 });
-            entity.add(TestProduct, { sku: 'MULTI', name: 'Multi Product', price: 50, inStock: true });
-            await entity.save();
+        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)
@@ -294,10 +312,15 @@ describe('Query Execution', () => {
                 .populate()
                 .exec();
 
-            const found = results.find(e => e.id === entity.id);
-            expect(found).toBeDefined();
-            expect(found?.getInMemory(TestUser)).toBeDefined();
-            expect(found?.getInMemory(TestProduct)).toBeDefined();
+            // 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 () => {
@@ -318,6 +341,36 @@ describe('Query Execution', () => {
             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()', () => {

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

@@ -0,0 +1,214 @@
+/**
+ * Integration tests for JSONB Array Query Operators
+ * Tests CONTAINS (@>), CONTAINED_BY (<@), HAS_ANY (?|), HAS_ALL (?&)
+ */
+import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
+import { Query, FilterOp } from '../../../query/Query';
+import { BaseComponent } from '../../../core/components/BaseComponent';
+import { Component, CompData } from '../../../core/components/Decorators';
+import { createTestContext, ensureComponentsRegistered } from '../../utils';
+
+@Component
+class TaggedItem extends BaseComponent {
+    @CompData({ indexed: true, arrayOf: String })
+    tags: string[] = [];
+
+    @CompData({ indexed: true })
+    name: string = '';
+}
+
+@Component
+class CategoryItem extends BaseComponent {
+    @CompData({ indexed: true })
+    title: string = '';
+}
+
+const isPGlite = process.env.USE_PGLITE === 'true';
+
+describe('JSONB Array Query Operators', () => {
+    const ctx = createTestContext();
+
+    beforeAll(async () => {
+        await ensureComponentsRegistered(TaggedItem, CategoryItem);
+    });
+
+    beforeEach(async () => {
+        // entity1: tags = ["red", "blue"]
+        const e1 = ctx.tracker.create();
+        e1.add(TaggedItem, { tags: ['red', 'blue'], name: 'item1' });
+        await e1.save();
+
+        // entity2: tags = ["blue", "green"]
+        const e2 = ctx.tracker.create();
+        e2.add(TaggedItem, { tags: ['blue', 'green'], name: 'item2' });
+        await e2.save();
+
+        // entity3: tags = ["red", "green", "blue"]
+        const e3 = ctx.tracker.create();
+        e3.add(TaggedItem, { tags: ['red', 'green', 'blue'], name: 'item3' });
+        await e3.save();
+
+        // entity4: tags = ["yellow"]
+        const e4 = ctx.tracker.create();
+        e4.add(TaggedItem, { tags: ['yellow'], name: 'item4' });
+        await e4.save();
+    });
+
+    describe('CONTAINS (@>)', () => {
+        test('finds entities where array contains a single value', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'red')]
+                })
+                .exec();
+
+            // item1 (red,blue) and item3 (red,green,blue)
+            expect(results.length).toBe(2);
+        });
+
+        test('finds entities where array contains multiple values (AND)', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.CONTAINS, ['red', 'blue'])]
+                })
+                .exec();
+
+            // item1 (red,blue) and item3 (red,green,blue) both have red AND blue
+            expect(results.length).toBe(2);
+        });
+
+        test('returns empty when no match', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'purple')]
+                })
+                .exec();
+
+            expect(results.length).toBe(0);
+        });
+
+        test('single element array matches', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'yellow')]
+                })
+                .exec();
+
+            expect(results.length).toBe(1);
+        });
+
+        test('combined with other filters', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [
+                        Query.filter('tags', FilterOp.CONTAINS, 'red'),
+                        Query.filter('name', FilterOp.EQ, 'item1'),
+                    ]
+                })
+                .exec();
+
+            expect(results.length).toBe(1);
+        });
+    });
+
+    describe('CONTAINED_BY (<@)', () => {
+        test('finds entities whose array is a subset of given values', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.CONTAINED_BY, ['red', 'blue'])]
+                })
+                .exec();
+
+            // Only item1 (red,blue) is a subset of [red,blue]
+            expect(results.length).toBe(1);
+        });
+
+        test('superset input matches all subsets', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.CONTAINED_BY, ['red', 'blue', 'green', 'yellow'])]
+                })
+                .exec();
+
+            // All 4 entities are subsets
+            expect(results.length).toBe(4);
+        });
+    });
+
+    describe.skipIf(isPGlite)('HAS_ANY (?|)', () => {
+        test('finds entities with any of the given values', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.HAS_ANY, ['red', 'yellow'])]
+                })
+                .exec();
+
+            // item1 (red), item3 (red), item4 (yellow)
+            expect(results.length).toBe(3);
+        });
+
+        test('single value works', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.HAS_ANY, ['yellow'])]
+                })
+                .exec();
+
+            expect(results.length).toBe(1);
+        });
+    });
+
+    describe.skipIf(isPGlite)('HAS_ALL (?&)', () => {
+        test('finds entities with all of the given values', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.HAS_ALL, ['red', 'green'])]
+                })
+                .exec();
+
+            // Only item3 (red,green,blue) has both red AND green
+            expect(results.length).toBe(1);
+        });
+
+        test('single value matches all entities containing it', async () => {
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.HAS_ALL, ['blue'])]
+                })
+                .exec();
+
+            // item1, item2, item3 all have blue
+            expect(results.length).toBe(3);
+        });
+    });
+
+    describe('multi-component INTERSECT compatibility', () => {
+        test('CONTAINS works with multiple .with() components', async () => {
+            // Add a second component to one entity
+            const e = ctx.tracker.create();
+            e.add(TaggedItem, { tags: ['special'], name: 'multi' });
+            e.add(CategoryItem, { title: 'test-category' });
+            await e.save();
+
+            const results = await new Query()
+                .with(TaggedItem, {
+                    filters: [Query.filter('tags', FilterOp.CONTAINS, 'special')]
+                })
+                .with(CategoryItem)
+                .exec();
+
+            expect(results.length).toBe(1);
+        });
+    });
+
+    describe('validation', () => {
+        test('rejects null value via validator', () => {
+            expect(() => {
+                new Query()
+                    .with(TaggedItem, {
+                        filters: [Query.filter('tags', FilterOp.CONTAINS, null)]
+                    });
+            }).not.toThrow(); // Filter creation succeeds, validation happens at exec time
+        });
+    });
+});

package/tests/integration/remote/dlq.test.ts

@@ -0,0 +1,175 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { RemoteManager } from "../../../core/remote/RemoteManager";
+import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
+import { createMockRedisFactory } from "../../helpers/MockRedisClient";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("Dead Letter Queue", () => {
+    let server: MockRedisStreamServer;
+    let producer: RemoteManager;
+
+    beforeEach(async () => {
+        server = new MockRedisStreamServer();
+        producer = new RemoteManager({
+            appName: "prod",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            shutdownDrainMs: 100,
+        });
+        await producer.start();
+    });
+
+    afterEach(async () => {
+        await producer.shutdown();
+    });
+
+    test("poison message routed to DLQ after second delivery", async () => {
+        // Consumer 1: handler fails → message stays in PEL with deliveryCount=1
+        const c1 = new RemoteManager({
+            appName: "cons",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+        });
+        await c1.start();
+        c1.on(
+            "poison",
+            async () => {
+                throw new Error("always fails");
+            },
+            "h1"
+        );
+        await producer.emit("cons", "poison", { bad: true });
+        await wait(200);
+        expect(server.getPelSize("remote:cons", "cons")).toBe(1);
+        await c1.shutdown();
+
+        // Consumer 2: autoClaimIdleMs > 0 triggers XAUTOCLAIM on startup →
+        // claims the orphan, deliveryCount becomes 2 → DLQ check fires.
+        const c2 = new RemoteManager({
+            appName: "cons",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 1,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+            enableLogging: true,
+        });
+        await c2.start();
+        c2.on(
+            "poison",
+            async () => {
+                throw new Error("still fails");
+            },
+            "h1"
+        );
+        await wait(300);
+
+        expect(server.getStreamLength("remote:cons:dlq")).toBe(1);
+        const snap = c2.getMetrics();
+        expect(snap.events.dlq).toBe(1);
+
+        await c2.shutdown();
+    });
+
+    test("dlqMaxDeliveries=0 disables DLQ routing", async () => {
+        const c1 = new RemoteManager({
+            appName: "cons2",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 0,
+            shutdownDrainMs: 100,
+        });
+        await c1.start();
+        c1.on(
+            "fail",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await producer.emit("cons2", "fail", {});
+        await wait(200);
+        await c1.shutdown();
+
+        const c2 = new RemoteManager({
+            appName: "cons2",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 1,
+            dlqMaxDeliveries: 0,
+            shutdownDrainMs: 100,
+        });
+        await c2.start();
+        c2.on(
+            "fail",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await wait(300);
+
+        expect(server.getStreamLength("remote:cons2:dlq")).toBe(0);
+
+        await c2.shutdown();
+    });
+
+    test("DLQ entry carries original_id + delivery_count metadata", async () => {
+        const c1 = new RemoteManager({
+            appName: "cons3",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+        });
+        await c1.start();
+        c1.on(
+            "p",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await producer.emit("cons3", "p", {});
+        await wait(200);
+        await c1.shutdown();
+
+        const c2 = new RemoteManager({
+            appName: "cons3",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 1,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+        });
+        await c2.start();
+        c2.on(
+            "p",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await wait(300);
+
+        const dlqEntries = server.xrange("remote:cons3:dlq", "-", "+");
+        expect(dlqEntries.length).toBe(1);
+        const [, fields] = dlqEntries[0]!;
+        // fields = [k1, v1, k2, v2, ...]
+        const flat = fields as string[];
+        const idx = (k: string) => flat.indexOf(k);
+        expect(idx("original_id")).toBeGreaterThanOrEqual(0);
+        expect(idx("delivery_count")).toBeGreaterThanOrEqual(0);
+        expect(idx("moved_at")).toBeGreaterThanOrEqual(0);
+        expect(idx("data")).toBeGreaterThanOrEqual(0);
+
+        await c2.shutdown();
+    });
+});

package/tests/integration/remote/event-dispatch.test.ts

@@ -0,0 +1,114 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { RemoteManager } from "../../../core/remote/RemoteManager";
+import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
+import { createMockRedisFactory } from "../../helpers/MockRedisClient";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("Event round-trip over mock Redis", () => {
+    let server: MockRedisStreamServer;
+    let appA: RemoteManager;
+    let appB: RemoteManager;
+
+    beforeEach(async () => {
+        server = new MockRedisStreamServer();
+        appA = new RemoteManager({
+            appName: "app-a",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 50,
+            autoClaimIdleMs: 0, // skip orphan reclaim
+            dlqMaxDeliveries: 0, // no DLQ for basic tests
+        });
+        appB = new RemoteManager({
+            appName: "app-b",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 50,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 0,
+        });
+        await appA.start();
+        await appB.start();
+    });
+
+    afterEach(async () => {
+        await appA.shutdown();
+        await appB.shutdown();
+    });
+
+    test("emit from A is received by B's handler", async () => {
+        const received: any[] = [];
+        appB.on(
+            "order.created",
+            async (data, ctx) => {
+                received.push({ data, sourceApp: ctx.sourceApp });
+            },
+            "h1"
+        );
+
+        await appA.emit("app-b", "order.created", { orderId: "abc" });
+        await wait(150);
+
+        expect(received).toHaveLength(1);
+        expect(received[0].data).toEqual({ orderId: "abc" });
+        expect(received[0].sourceApp).toBe("app-a");
+    });
+
+    test("handler receives ctx.attempt=1 on first delivery", async () => {
+        const attempts: number[] = [];
+        appB.on(
+            "x",
+            async (_data, ctx) => {
+                attempts.push(ctx.attempt);
+            },
+            "h1"
+        );
+        await appA.emit("app-b", "x", {});
+        await wait(150);
+        expect(attempts).toEqual([1]);
+    });
+
+    test("no-handler event is ACKed silently", async () => {
+        await appA.emit("app-b", "unhandled.event", {});
+        await wait(150);
+        // PEL should be empty after ACK
+        expect(server.getPelSize("remote:app-b", "app-b")).toBe(0);
+        const snap = appB.getMetrics();
+        expect(snap.events.noHandler).toBeGreaterThan(0);
+    });
+
+    test("multiple handlers all fire for one event", async () => {
+        const log: string[] = [];
+        appB.on("e", async () => { log.push("h1"); }, "h1");
+        appB.on("e", async () => { log.push("h2"); }, "h2");
+        await appA.emit("app-b", "e", {});
+        await wait(150);
+        expect(log.sort()).toEqual(["h1", "h2"]);
+    });
+
+    test("handler failure leaves message in PEL (no ACK)", async () => {
+        appB.on(
+            "fail",
+            async () => {
+                throw new Error("handler boom");
+            },
+            "h1"
+        );
+        await appA.emit("app-b", "fail", {});
+        await wait(150);
+        expect(server.getPelSize("remote:app-b", "app-b")).toBe(1);
+        const snap = appB.getMetrics();
+        expect(snap.events.handlerFailed).toBe(1);
+    });
+
+    test("metrics reflect emit + receive counters", async () => {
+        appB.on("m", async () => {}, "h1");
+        await appA.emit("app-b", "m", {});
+        await appA.emit("app-b", "m", {});
+        await wait(200);
+
+        const aSnap = appA.getMetrics();
+        const bSnap = appB.getMetrics();
+        expect(aSnap.emit.direct).toBe(2);
+        expect(bSnap.events.handled).toBe(2);
+    });
+});