bunsane 0.3.2 → 0.4.0

package/tests/unit/upload/RestUpload.test.ts

@@ -1,267 +0,0 @@
-import { describe, it, expect, beforeEach, mock, spyOn } from "bun:test";
-import {
-    parseFormData,
-    handleUpload,
-    uploadResponse,
-    uploadErrorResponse,
-} from "../../../upload/RestUpload";
-import { UploadManager } from "../../../upload/UploadManager";
-import type { UploadResult } from "../../../types/upload.types";
-
-function createMultipartRequest(
-    files: { name: string; content: string; type: string; fieldName?: string }[],
-    fields?: Record<string, string>,
-): Request {
-    const formData = new FormData();
-    for (const f of files) {
-        const file = new File([f.content], f.name, { type: f.type });
-        formData.append(f.fieldName ?? "file", file);
-    }
-    if (fields) {
-        for (const [k, v] of Object.entries(fields)) {
-            formData.append(k, v);
-        }
-    }
-    return new Request("http://localhost/upload", {
-        method: "POST",
-        body: formData,
-    });
-}
-
-describe("parseFormData", () => {
-    it("extracts files and text fields", async () => {
-        const req = createMultipartRequest(
-            [{ name: "photo.png", content: "imagedata", type: "image/png" }],
-            { description: "My photo", tag: "avatar" },
-        );
-
-        const { files, fields } = await parseFormData(req);
-        expect(files).toHaveLength(1);
-        expect(files[0]!.file.name).toBe("photo.png");
-        expect(files[0]!.fieldName).toBe("file");
-        expect(fields["description"]).toBe("My photo");
-        expect(fields["tag"]).toBe("avatar");
-    });
-
-    it("handles multiple files", async () => {
-        const req = createMultipartRequest([
-            { name: "a.png", content: "a", type: "image/png", fieldName: "photos" },
-            { name: "b.jpg", content: "b", type: "image/jpeg", fieldName: "photos" },
-        ]);
-
-        const { files } = await parseFormData(req);
-        expect(files).toHaveLength(2);
-        expect(files[0]!.file.name).toBe("a.png");
-        expect(files[1]!.file.name).toBe("b.jpg");
-    });
-
-    it("throws for non-multipart Content-Type", async () => {
-        const req = new Request("http://localhost/upload", {
-            method: "POST",
-            body: JSON.stringify({ data: "test" }),
-            headers: { "Content-Type": "application/json" },
-        });
-
-        await expect(parseFormData(req)).rejects.toThrow(
-            "Invalid Content-Type: expected multipart/form-data",
-        );
-    });
-
-    it("returns empty files array when no files in form", async () => {
-        const formData = new FormData();
-        formData.append("name", "test");
-        const req = new Request("http://localhost/upload", {
-            method: "POST",
-            body: formData,
-        });
-
-        const { files, fields } = await parseFormData(req);
-        expect(files).toHaveLength(0);
-        expect(fields.name).toBe("test");
-    });
-});
-
-describe("handleUpload", () => {
-    const successResult: UploadResult = {
-        success: true,
-        uploadId: "uid-1",
-        fileName: "test.png",
-        originalFileName: "photo.png",
-        mimeType: "image/png",
-        size: 1024,
-        path: "uploads/test.png",
-        url: "/uploads/test.png",
-    };
-
-    const failResult: UploadResult = {
-        success: false,
-        error: {
-            uploadId: "uid-2",
-            code: "VALIDATION_FAILED",
-            message: "File too large",
-        },
-    };
-
-    let uploadFileSpy: ReturnType<typeof spyOn>;
-
-    beforeEach(() => {
-        uploadFileSpy = spyOn(
-            UploadManager.getInstance(),
-            "uploadFile",
-        ).mockResolvedValue(successResult);
-        uploadFileSpy.mockClear();
-    });
-
-    it("pipes files through UploadManager", async () => {
-        const req = createMultipartRequest([
-            { name: "photo.png", content: "data", type: "image/png" },
-        ]);
-
-        const result = await handleUpload(req);
-        expect(result.success).toBe(true);
-        expect(result.totalFiles).toBe(1);
-        expect(result.successCount).toBe(1);
-        expect(result.failureCount).toBe(0);
-        expect(result.files).toHaveLength(1);
-        expect(uploadFileSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("enforces maxFiles limit", async () => {
-        const req = createMultipartRequest([
-            { name: "a.png", content: "a", type: "image/png" },
-            { name: "b.png", content: "b", type: "image/png" },
-            { name: "c.png", content: "c", type: "image/png" },
-        ]);
-
-        await expect(handleUpload(req, { maxFiles: 2 })).rejects.toThrow(
-            "Too many files: received 3, maximum is 2",
-        );
-    });
-
-    it("filters by fieldNames", async () => {
-        const req = createMultipartRequest([
-            { name: "a.png", content: "a", type: "image/png", fieldName: "avatar" },
-            { name: "b.png", content: "b", type: "image/png", fieldName: "banner" },
-        ]);
-
-        const result = await handleUpload(req, { fieldNames: ["avatar"] });
-        expect(result.totalFiles).toBe(1);
-        expect(uploadFileSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("passes config and storageProvider to UploadManager", async () => {
-        const req = createMultipartRequest([
-            { name: "a.png", content: "a", type: "image/png" },
-        ]);
-        const config = { maxFileSize: 5_000_000 };
-
-        await handleUpload(req, { config, storageProvider: "s3" });
-        expect(uploadFileSpy).toHaveBeenCalledWith(
-            expect.any(File),
-            config,
-            "s3",
-        );
-    });
-
-    it("reports partial failures correctly", async () => {
-        let callCount = 0;
-        uploadFileSpy.mockImplementation(async () => {
-            callCount++;
-            return callCount === 1 ? successResult : failResult;
-        });
-
-        const req = createMultipartRequest([
-            { name: "a.png", content: "a", type: "image/png" },
-            { name: "b.png", content: "b", type: "image/png" },
-        ]);
-
-        const result = await handleUpload(req);
-        expect(result.success).toBe(false);
-        expect(result.successCount).toBe(1);
-        expect(result.failureCount).toBe(1);
-    });
-
-    it("includes text fields in result", async () => {
-        const req = createMultipartRequest(
-            [{ name: "a.png", content: "a", type: "image/png" }],
-            { title: "My Upload" },
-        );
-
-        const result = await handleUpload(req);
-        expect(result.fields.title).toBe("My Upload");
-    });
-});
-
-describe("uploadResponse", () => {
-    it("returns 200 for all-success", () => {
-        const result = {
-            success: true,
-            files: [],
-            fields: {},
-            totalFiles: 2,
-            successCount: 2,
-            failureCount: 0,
-        };
-
-        const res = uploadResponse(result);
-        expect(res.status).toBe(200);
-        expect(res.headers.get("Content-Type")).toBe("application/json");
-    });
-
-    it("returns 207 for partial success", () => {
-        const result = {
-            success: false,
-            files: [],
-            fields: {},
-            totalFiles: 2,
-            successCount: 1,
-            failureCount: 1,
-        };
-
-        const res = uploadResponse(result);
-        expect(res.status).toBe(207);
-    });
-
-    it("returns 400 when all failed", () => {
-        const result = {
-            success: false,
-            files: [],
-            fields: {},
-            totalFiles: 2,
-            successCount: 0,
-            failureCount: 2,
-        };
-
-        const res = uploadResponse(result);
-        expect(res.status).toBe(400);
-    });
-});
-
-describe("uploadErrorResponse", () => {
-    it("returns error JSON with default status", async () => {
-        const res = uploadErrorResponse(new Error("Bad file"));
-        expect(res.status).toBe(400);
-
-        const body = await res.json();
-        expect(body.error).toBe("Bad file");
-        expect(body.code).toBe("UPLOAD_FAILED");
-    });
-
-    it("uses custom code and status", async () => {
-        const res = uploadErrorResponse(
-            new Error("Too big"),
-            "FILE_TOO_LARGE",
-            413,
-        );
-        expect(res.status).toBe(413);
-
-        const body = await res.json();
-        expect(body.code).toBe("FILE_TOO_LARGE");
-    });
-
-    it("handles non-Error values", async () => {
-        const res = uploadErrorResponse("something went wrong");
-        const body = await res.json();
-        expect(body.error).toBe("Unknown upload error");
-    });
-});

package/tests/unit/validateEnv.test.ts

@@ -1,82 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { validateEnv } from "../../core/validateEnv";
-
-describe("validateEnv", () => {
-    let savedEnv: NodeJS.ProcessEnv;
-
-    beforeEach(() => {
-        savedEnv = { ...process.env };
-        // Clear all DB-related env vars
-        delete process.env.DB_CONNECTION_URL;
-        delete process.env.POSTGRES_HOST;
-        delete process.env.POSTGRES_USER;
-        delete process.env.POSTGRES_PASSWORD;
-        delete process.env.POSTGRES_DB;
-        delete process.env.POSTGRES_PORT;
-        delete process.env.POSTGRES_MAX_CONNECTIONS;
-        delete process.env.APP_PORT;
-        delete process.env.NODE_ENV;
-        delete process.env.GRAPHQL_MAX_DEPTH;
-    });
-
-    afterEach(() => {
-        process.env = savedEnv;
-    });
-
-    test("passes with DB_CONNECTION_URL", () => {
-        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
-        expect(() => validateEnv()).not.toThrow();
-    });
-
-    test("passes with POSTGRES_HOST + POSTGRES_USER + POSTGRES_DB", () => {
-        process.env.POSTGRES_HOST = "localhost";
-        process.env.POSTGRES_USER = "user";
-        process.env.POSTGRES_DB = "testdb";
-        expect(() => validateEnv()).not.toThrow();
-    });
-
-    test("throws when neither DB connection method provided", () => {
-        expect(() => validateEnv()).toThrow("Database connection required");
-    });
-
-    test("throws for non-numeric APP_PORT", () => {
-        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
-        process.env.APP_PORT = "abc";
-        expect(() => validateEnv()).toThrow("APP_PORT must be numeric");
-    });
-
-    test("throws for invalid NODE_ENV", () => {
-        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
-        process.env.NODE_ENV = "staging";
-        expect(() => validateEnv()).toThrow("Environment validation failed");
-    });
-
-    test("passes when optional vars omitted", () => {
-        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
-        // No APP_PORT, NODE_ENV, POSTGRES_PORT, POSTGRES_MAX_CONNECTIONS
-        expect(() => validateEnv()).not.toThrow();
-    });
-
-    test("throws for non-numeric POSTGRES_PORT", () => {
-        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
-        process.env.POSTGRES_PORT = "not-a-number";
-        expect(() => validateEnv()).toThrow("POSTGRES_PORT must be numeric");
-    });
-
-    test("throws for non-numeric POSTGRES_MAX_CONNECTIONS", () => {
-        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
-        process.env.POSTGRES_MAX_CONNECTIONS = "many";
-        expect(() => validateEnv()).toThrow(
-            "POSTGRES_MAX_CONNECTIONS must be numeric",
-        );
-    });
-
-    test("passes with valid optional numeric fields", () => {
-        process.env.DB_CONNECTION_URL = "postgres://user:pass@localhost:5432/db";
-        process.env.APP_PORT = "3000";
-        process.env.POSTGRES_PORT = "5432";
-        process.env.POSTGRES_MAX_CONNECTIONS = "20";
-        process.env.GRAPHQL_MAX_DEPTH = "15";
-        expect(() => validateEnv()).not.toThrow();
-    });
-});

package/tests/utils/entity-tracker.ts

@@ -1,57 +0,0 @@
-/**
- * Entity tracker for automatic cleanup in tests
- */
-import { Entity } from '../../core/Entity';
-
-/**
- * Tracks entities created during a test for cleanup
- */
-export class EntityTracker {
-    private entities: Entity[] = [];
-
-    /**
-     * Track an entity for cleanup after the test
-     */
-    track(entity: Entity): Entity {
-        this.entities.push(entity);
-        return entity;
-    }
-
-    /**
-     * Create and track a new entity
-     */
-    create(id?: string): Entity {
-        const entity = new Entity(id);
-        return this.track(entity);
-    }
-
-    /**
-     * Clean up all tracked entities (soft delete by default)
-     */
-    async cleanup(hardDelete: boolean = true): Promise<void> {
-        for (const entity of this.entities) {
-            try {
-                if (entity._persisted) {
-                    await entity.delete(hardDelete);
-                }
-            } catch {
-                // Ignore cleanup errors - entity may already be deleted
-            }
-        }
-        this.entities = [];
-    }
-
-    /**
-     * Get count of tracked entities
-     */
-    get count(): number {
-        return this.entities.length;
-    }
-
-    /**
-     * Get all tracked entities
-     */
-    get all(): Entity[] {
-        return [...this.entities];
-    }
-}

package/tests/utils/index.ts

@@ -1,13 +0,0 @@
-/**
- * Re-export all test utilities
- */
-export { EntityTracker } from './entity-tracker';
-export {
-    createTestContext,
-    createTestContextWithoutCache,
-    ensureComponentRegistered,
-    ensureComponentsRegistered,
-    generateTestId,
-    delay,
-    type TestContext
-} from './test-context';

package/tests/utils/test-context.ts

@@ -1,149 +0,0 @@
-/**
- * Test context factory for setting up and tearing down test environments
- */
-import { beforeEach, afterEach } from 'bun:test';
-import { EntityTracker } from './entity-tracker';
-import { CacheManager } from '../../core/cache';
-import EntityManager from '../../core/EntityManager';
-import { ComponentRegistry } from '../../core/components';
-import db from '../../database';
-import { preparedStatementCache } from '../../database/PreparedStatementCache';
-
-export interface TestContext {
-    tracker: EntityTracker;
-    cacheManager: CacheManager;
-    db: typeof db;
-}
-
-/**
- * Creates a test context with automatic setup and cleanup
- *
- * Usage:
- * ```typescript
- * describe('My Test', () => {
- *     const ctx = createTestContext();
- *
- *     test('should work', async () => {
- *         const entity = ctx.tracker.create();
- *         entity.add(MyComponent, { value: 'test' });
- *         await entity.save();
- *         // Entity will be automatically cleaned up after test
- *     });
- * });
- * ```
- */
-export function createTestContext(): TestContext {
-    const tracker = new EntityTracker();
-    let cacheManager: CacheManager;
-
-    beforeEach(async () => {
-        // Ensure EntityManager is ready
-        (EntityManager as any).dbReady = true;
-
-        // Initialize cache with memory provider
-        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 }
-        });
-
-        // Clear cache before each test
-        await cacheManager.getProvider().clear();
-
-        // Clear prepared statement cache to prevent cache pollution between tests
-        preparedStatementCache.clear();
-    });
-
-    afterEach(async () => {
-        // Clean up tracked entities
-        await tracker.cleanup();
-
-        // Clear cache after test
-        try {
-            await cacheManager?.getProvider().clear();
-        } catch {
-            // Ignore
-        }
-    });
-
-    return {
-        tracker,
-        get cacheManager() {
-            return CacheManager.getInstance();
-        },
-        db
-    };
-}
-
-/**
- * Creates a test context with cache disabled
- */
-export function createTestContextWithoutCache(): TestContext {
-    const tracker = new EntityTracker();
-
-    beforeEach(async () => {
-        (EntityManager as any).dbReady = true;
-        const cacheManager = CacheManager.getInstance();
-        await cacheManager.initialize({
-            enabled: false,
-            provider: 'memory',
-            strategy: 'write-through',
-            defaultTTL: 0,
-            entity: { enabled: false, ttl: 0 },
-            component: { enabled: false, ttl: 0 },
-            query: { enabled: false, ttl: 0, maxSize: 10000 }
-        });
-    });
-
-    afterEach(async () => {
-        await tracker.cleanup();
-    });
-
-    return {
-        tracker,
-        get cacheManager() {
-            return CacheManager.getInstance();
-        },
-        db
-    };
-}
-
-/**
- * Ensures a component is registered before running tests
- */
-export async function ensureComponentRegistered(
-    componentClass: new (...args: any[]) => any
-): Promise<void> {
-    const componentName = componentClass.name;
-    await ComponentRegistry.getReadyPromise(componentName);
-}
-
-/**
- * Ensures multiple components are registered before running tests
- */
-export async function ensureComponentsRegistered(
-    ...componentClasses: Array<new (...args: any[]) => any>
-): Promise<void> {
-    await Promise.all(componentClasses.map(c => ensureComponentRegistered(c)));
-}
-
-/**
- * Generates a unique test ID
- */
-export function generateTestId(prefix: string = 'test'): string {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2, 8);
-    return `${prefix}-${timestamp}-${random}`;
-}
-
-/**
- * Creates a delay (useful for testing async operations)
- */
-export function delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}