bunsane 0.3.1 → 0.4.0

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

@@ -1,114 +0,0 @@
-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);
-    });
-});

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

@@ -1,130 +0,0 @@
-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";
-import db from "../../../database";
-
-const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
-
-describe("Transactional Outbox", () => {
-    let server: MockRedisStreamServer;
-    let app: RemoteManager;
-
-    beforeEach(async () => {
-        // Clear any residual outbox rows from earlier tests
-        try {
-            await db`DELETE FROM remote_outbox`;
-        } catch {
-            /* table may not exist yet */
-        }
-        server = new MockRedisStreamServer();
-        app = new RemoteManager({
-            appName: "app",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 30,
-            autoClaimIdleMs: 0,
-            dlqMaxDeliveries: 0,
-            shutdownDrainMs: 100,
-            enableOutbox: true,
-            outboxPollIntervalMs: 50,
-            outboxBatchSize: 10,
-        });
-        await app.start();
-    });
-
-    afterEach(async () => {
-        await app.shutdown();
-    });
-
-    test("emit({ trx }) inserts outbox row within transaction", async () => {
-        await (db as any).begin(async (trx: any) => {
-            const id = await app.emit(
-                "downstream",
-                "order.created",
-                { orderId: "abc" },
-                { trx }
-            );
-            expect(id).toBeDefined();
-        });
-
-        const rows = await db`
-            SELECT target, event, data, published_at
-            FROM remote_outbox
-        `;
-        expect(rows.length).toBe(1);
-        expect(rows[0]!.target).toBe("downstream");
-        expect(rows[0]!.event).toBe("order.created");
-    });
-
-    test("worker publishes committed rows to Redis + marks published_at", async () => {
-        await (db as any).begin(async (trx: any) => {
-            await app.emit(
-                "downstream",
-                "published.event",
-                { n: 1 },
-                { trx }
-            );
-        });
-        await wait(200); // allow at least one poll tick
-
-        // Row should now be marked published
-        const rows = await db`
-            SELECT published_at FROM remote_outbox
-            WHERE event = 'published.event'
-        `;
-        expect(rows[0]!.published_at).not.toBeNull();
-
-        // Stream should have the message
-        expect(server.getStreamLength("remote:downstream")).toBeGreaterThanOrEqual(
-            1
-        );
-    });
-
-    test("rolled-back transaction suppresses publish", async () => {
-        try {
-            await (db as any).begin(async (trx: any) => {
-                await app.emit(
-                    "downstream",
-                    "rolled.back",
-                    { n: 2 },
-                    { trx }
-                );
-                throw new Error("force rollback");
-            });
-        } catch {
-            /* expected */
-        }
-        await wait(200);
-
-        const rows = await db`
-            SELECT COUNT(*)::int AS c FROM remote_outbox
-            WHERE event = 'rolled.back'
-        `;
-        expect(rows[0]!.c).toBe(0);
-        expect(server.getStreamLength("remote:downstream")).toBe(0);
-    });
-
-    test("direct emit + outbox emit hit same target stream", async () => {
-        await app.emit("other", "direct", { n: "a" });
-        await (db as any).begin(async (trx: any) => {
-            await app.emit("other", "outbox", { n: "b" }, { trx });
-        });
-        await wait(200);
-
-        const entries = server.xrange("remote:other", "-", "+");
-        expect(entries.length).toBe(2);
-    });
-
-    test("metrics count emit.direct vs emit.outbox separately", async () => {
-        await app.emit("dst", "direct", {});
-        await (db as any).begin(async (trx: any) => {
-            await app.emit("dst", "outbox", {}, { trx });
-        });
-        await wait(150);
-
-        const snap = app.getMetrics();
-        expect(snap.emit.direct).toBe(1);
-        expect(snap.emit.outbox).toBe(1);
-        expect(snap.outbox.published).toBeGreaterThanOrEqual(1);
-    });
-});

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

@@ -1,177 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { RemoteManager } from "../../../core/remote/RemoteManager";
-import { RemoteError } from "../../../core/remote/types";
-import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
-import { createMockRedisFactory } from "../../helpers/MockRedisClient";
-
-describe("RPC round-trip", () => {
-    let server: MockRedisStreamServer;
-    let client: RemoteManager;
-    let server_app: RemoteManager;
-
-    beforeEach(async () => {
-        server = new MockRedisStreamServer();
-        client = new RemoteManager({
-            appName: "client-app",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 50,
-            autoClaimIdleMs: 0,
-            dlqMaxDeliveries: 0,
-            shutdownDrainMs: 100,
-            defaultCallTimeout: 1000,
-        });
-        server_app = new RemoteManager({
-            appName: "server-app",
-            redisFactory: createMockRedisFactory(server),
-            blockMs: 50,
-            autoClaimIdleMs: 0,
-            dlqMaxDeliveries: 0,
-            shutdownDrainMs: 100,
-        });
-        await client.start();
-        await server_app.start();
-    });
-
-    afterEach(async () => {
-        await client.shutdown();
-        await server_app.shutdown();
-    });
-
-    test("call() returns handler result", async () => {
-        server_app.onRpc(
-            "order.get",
-            async (data: any) => ({ id: data.id, status: "ok" }),
-            "h1"
-        );
-        const result = await client.call<{ id: string; status: string }>(
-            "server-app",
-            "order.get",
-            { id: "abc" }
-        );
-        expect(result).toEqual({ id: "abc", status: "ok" });
-    });
-
-    test("call() rejects with TIMEOUT when no handler registered", async () => {
-        // server_app has no handler — still returns NOT_FOUND, not TIMEOUT
-        try {
-            await client.call(
-                "server-app",
-                "nonexistent.method",
-                {},
-                { timeout: 500 }
-            );
-            throw new Error("expected throw");
-        } catch (err) {
-            expect(err).toBeInstanceOf(RemoteError);
-            expect((err as RemoteError).code).toBe("NOT_FOUND");
-        }
-    });
-
-    test("call() rejects with TIMEOUT when target app down", async () => {
-        // Kill server_app — no consumer for the request stream
-        await server_app.shutdown();
-        try {
-            await client.call(
-                "server-app",
-                "anything",
-                {},
-                { timeout: 200 }
-            );
-            throw new Error("expected throw");
-        } catch (err) {
-            expect(err).toBeInstanceOf(RemoteError);
-            expect((err as RemoteError).code).toBe("TIMEOUT");
-        }
-    });
-
-    test("call() to broadcast target * rejects INVALID_TARGET", async () => {
-        try {
-            await client.call("*", "anything", {});
-            throw new Error("expected throw");
-        } catch (err) {
-            expect(err).toBeInstanceOf(RemoteError);
-            expect((err as RemoteError).code).toBe("INVALID_TARGET");
-        }
-    });
-
-    test("handler exception propagates as HANDLER_ERROR", async () => {
-        server_app.onRpc(
-            "fail",
-            async () => {
-                throw new Error("something bad");
-            },
-            "h1"
-        );
-        try {
-            await client.call("server-app", "fail", {});
-            throw new Error("expected throw");
-        } catch (err) {
-            expect(err).toBeInstanceOf(RemoteError);
-            expect((err as RemoteError).code).toBe("HANDLER_ERROR");
-        }
-    });
-
-    test("handler custom RemoteError code flows through", async () => {
-        server_app.onRpc(
-            "forbidden",
-            async () => {
-                throw new RemoteError("no", {
-                    code: "FORBIDDEN",
-                    extensions: { reason: "test" },
-                });
-            },
-            "h1"
-        );
-        try {
-            await client.call("server-app", "forbidden", {});
-            throw new Error("expected throw");
-        } catch (err) {
-            expect(err).toBeInstanceOf(RemoteError);
-            const re = err as RemoteError;
-            expect(re.code).toBe("FORBIDDEN");
-            expect(re.extensions).toEqual({ reason: "test" });
-        }
-    });
-
-    test("ctx carries correlationId + deadline", async () => {
-        let captured: any = null;
-        server_app.onRpc(
-            "ctx-check",
-            async (_data, ctx) => {
-                captured = {
-                    correlationId: ctx.correlationId,
-                    deadline: ctx.deadline,
-                    sourceApp: ctx.sourceApp,
-                };
-                return null;
-            },
-            "h1"
-        );
-        await client.call("server-app", "ctx-check", {}, { timeout: 2000 });
-        expect(captured.correlationId).toMatch(/^[0-9a-f-]{36}$/);
-        expect(captured.deadline).toBeInstanceOf(Date);
-        expect(captured.sourceApp).toBe("client-app");
-    });
-
-    test("metrics track successful + failed RPCs", async () => {
-        server_app.onRpc("ok", async () => "x", "h1");
-        server_app.onRpc(
-            "bad",
-            async () => {
-                throw new Error("x");
-            },
-            "h2"
-        );
-        await client.call("server-app", "ok", {});
-        await client.call("server-app", "bad", {}).catch(() => {});
-
-        const clientSnap = client.getMetrics();
-        expect(clientSnap.rpc.called).toBe(2);
-        expect(clientSnap.rpc.succeeded).toBe(1);
-        expect(clientSnap.rpc.failed).toBe(1);
-
-        const serverSnap = server_app.getMetrics();
-        expect(serverSnap.rpc.handlerExecuted).toBe(1);
-        expect(serverSnap.rpc.handlerFailed).toBe(1);
-    });
-});

package/tests/pglite-setup.ts

@@ -1,62 +0,0 @@
-/**
- * PGlite wrapper script for zero-infrastructure testing.
- *
- * Starts an in-memory PostgreSQL via PGlite Socket, then spawns
- * `bun test` with the correct env vars already set at the process level.
- * This avoids all preload ordering issues.
- *
- * Usage:
- *   bun tests/pglite-setup.ts [test-dirs...]
- *   bun tests/pglite-setup.ts tests/unit/
- *   bun tests/pglite-setup.ts tests/unit tests/integration tests/graphql
- */
-
-import { PGlite } from '@electric-sql/pglite';
-import { PGLiteSocketServer } from '@electric-sql/pglite-socket';
-import { spawn } from 'child_process';
-
-const PORT = 54321;
-
-console.log('[pglite] Starting in-memory PostgreSQL...');
-const pg = new PGlite();
-await pg.waitReady;
-
-const server = new PGLiteSocketServer({ db: pg, port: PORT });
-await server.start();
-console.log(`[pglite] Socket server running on port ${PORT}`);
-
-// Test dirs from CLI args, default to unit + integration + graphql
-const testDirs = process.argv.slice(2);
-if (testDirs.length === 0) {
-    testDirs.push('tests/unit', 'tests/integration', 'tests/graphql');
-}
-
-const proc = spawn('bun', ['test', ...testDirs], {
-    env: {
-        ...process.env,
-        USE_PGLITE: 'true',
-        DB_CONNECTION_URL: '', // Clear to use POSTGRES_* vars
-        POSTGRES_HOST: 'localhost',
-        POSTGRES_PORT: String(PORT),
-        POSTGRES_USER: 'postgres',
-        POSTGRES_PASSWORD: 'postgres',
-        POSTGRES_DB: 'postgres',
-        POSTGRES_MAX_CONNECTIONS: '1',
-    },
-    stdio: 'inherit',
-    cwd: process.cwd(),
-});
-
-proc.on('exit', async (code) => {
-    console.log('[pglite] Stopping server...');
-    try { await server.stop(); } catch {}
-    try { await pg.close(); } catch {}
-    process.exit(code ?? 1);
-});
-
-proc.on('error', async (err) => {
-    console.error('[pglite] Failed to spawn bun test:', err);
-    try { await server.stop(); } catch {}
-    try { await pg.close(); } catch {}
-    process.exit(1);
-});

package/tests/setup.ts

@@ -1,164 +0,0 @@
-/**
- * Global test setup file for BunSane
- *
- * This file is preloaded before all tests run (configured in bunfig.toml).
- * It ensures:
- * 1. Environment variables are loaded from .env.test
- * 2. Database connection is established and ready
- * 3. Base tables exist
- * 4. ApplicationLifecycle is set to DATABASE_READY
- * 5. EntityManager is ready for operations
- * 6. Proper cleanup on exit
- */
-
-import { beforeAll, afterAll } from 'bun:test';
-import { file } from 'bun';
-
-// Load .env.test before anything else (skip when PGlite provides env vars)
-if (process.env.USE_PGLITE !== 'true') {
-    const envTestPath = new URL('../.env.test', import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1');
-    const envFile = file(envTestPath);
-    if (await envFile.exists()) {
-        const envContent = await envFile.text();
-        for (const line of envContent.split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed && !trimmed.startsWith('#')) {
-                const [key, ...valueParts] = trimmed.split('=');
-                if (key) {
-                    const value = valueParts.join('=');
-                    process.env[key.trim()] = value.trim();
-                }
-            }
-        }
-    }
-}
-
-// Suppress verbose logging during tests unless LOG_LEVEL is explicitly set
-if (!process.env.LOG_LEVEL) {
-    process.env.LOG_LEVEL = 'warn';
-}
-
-// Now import the rest after env is loaded
-import db from '../database';
-import { PrepareDatabase, HasValidBaseTable } from '../database/DatabaseHelper';
-import ApplicationLifecycle, { ApplicationPhase } from '../core/ApplicationLifecycle';
-import EntityManager from '../core/EntityManager';
-import { ComponentRegistry } from '../core/components';
-import { CacheManager } from '../core/cache';
-import { logger } from '../core/Logger';
-import { preparedStatementCache } from '../database/PreparedStatementCache';
-
-let isSetupComplete = false;
-let setupError: Error | null = null;
-
-/**
- * Initialize the test environment
- */
-async function initializeTestEnvironment(): Promise<void> {
-    if (isSetupComplete) return;
-    if (setupError) throw setupError;
-
-    try {
-        logger.info({ scope: 'test-setup' }, 'Initializing test environment...');
-
-        // 1. Verify database connection by running a simple query
-        const connectionTest = await db`SELECT 1 as connected`;
-        if (!connectionTest || connectionTest.length === 0) {
-            throw new Error('Database connection failed');
-        }
-        logger.info({ scope: 'test-setup' }, 'Database connection verified');
-
-        // 2. Ensure base tables exist
-        const hasValidTables = await HasValidBaseTable();
-        if (!hasValidTables) {
-            logger.info({ scope: 'test-setup' }, 'Creating base database tables...');
-            await PrepareDatabase();
-            logger.info({ scope: 'test-setup' }, 'Base database tables created');
-        } else {
-            logger.info({ scope: 'test-setup' }, 'Base database tables already exist');
-        }
-
-        // 3. Set ApplicationLifecycle to DATABASE_READY
-        ApplicationLifecycle.setPhase(ApplicationPhase.DATABASE_READY);
-        logger.info({ scope: 'test-setup' }, 'ApplicationLifecycle set to DATABASE_READY');
-
-        // 4. Set EntityManager as ready
-        (EntityManager as any).dbReady = true;
-        logger.info({ scope: 'test-setup' }, 'EntityManager marked as ready');
-
-        // 5. Initialize CacheManager with memory provider for tests
-        const cacheManager = CacheManager.getInstance();
-        await 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 }
-        });
-        logger.info({ scope: 'test-setup' }, 'CacheManager initialized with memory provider');
-
-        // 6. Clear prepared statement cache to ensure clean slate
-        preparedStatementCache.clear();
-
-        isSetupComplete = true;
-        logger.info({ scope: 'test-setup' }, 'Test environment initialization complete');
-
-    } catch (error) {
-        setupError = error instanceof Error ? error : new Error(String(error));
-        logger.error({ scope: 'test-setup', error: setupError }, 'Failed to initialize test environment');
-        throw setupError;
-    }
-}
-
-/**
- * Clean up the test environment
- */
-async function cleanupTestEnvironment(): Promise<void> {
-    try {
-        logger.info({ scope: 'test-setup' }, 'Cleaning up test environment...');
-
-        // Clear caches
-        try {
-            const cacheManager = CacheManager.getInstance();
-            await cacheManager.clear();
-        } catch {
-            // Ignore cache cleanup errors
-        }
-
-        // Clear prepared statement cache
-        try {
-            preparedStatementCache.clear();
-        } catch {
-            // Ignore errors
-        }
-
-        // Note: We don't close the database connection pool here because
-        // Bun's test runner may still need it for parallel test files.
-        // The connection pool will be cleaned up when the process exits.
-
-        logger.info({ scope: 'test-setup' }, 'Test environment cleanup complete');
-    } catch (error) {
-        logger.warn({ scope: 'test-setup', error }, 'Error during test environment cleanup');
-    }
-}
-
-// Register global hooks (skip for E2E tests that don't need DB)
-if (process.env.SKIP_TEST_DB_SETUP !== 'true') {
-    beforeAll(async () => {
-        await initializeTestEnvironment();
-    });
-
-    afterAll(async () => {
-        await cleanupTestEnvironment();
-    });
-}
-
-// Export utilities for tests that need them
-export { initializeTestEnvironment, cleanupTestEnvironment };
-
-// Export a helper to ensure setup is complete (for tests that run before beforeAll)
-export async function ensureTestSetup(): Promise<void> {
-    await initializeTestEnvironment();
-}