bunsane 0.1.0 → 0.1.2

package/tests/component.test.ts

@@ -0,0 +1,338 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { BaseComponent, CompData, Component } from "../core/Components";
+import type { ComponentDataType } from "../core/Components";
+import { Entity } from "../core/Entity";
+import App from "../core/App";
+import ComponentRegistry from "../core/ComponentRegistry";
+import db from "../database";
+
+// Test component with 'value' attribute (standard assumption)
+@Component
+class ValueComponent extends BaseComponent {
+    @CompData()
+    value: string = "";
+}
+
+// Test component with different attribute name
+@Component
+class CustomAttributeComponent extends BaseComponent {
+    @CompData()
+    customData: string = "";
+}
+
+// Test component with multiple attributes
+@Component
+class MultiAttributeComponent extends BaseComponent {
+    @CompData()
+    title: string = "";
+    @CompData()
+    content: string = "";
+    @CompData({ indexed: true })
+    category: string = "";
+}
+
+// Test component with no data attributes
+@Component
+class NoDataComponent extends BaseComponent {
+    // No @CompData properties
+}
+
+// Test component with numeric value
+@Component
+class NumericComponent extends BaseComponent {
+    @CompData()
+    count: number = 0;
+}
+
+// Test component with boolean value
+@Component
+class BooleanComponent extends BaseComponent {
+    @CompData()
+    enabled: boolean = false;
+}
+
+let app: App;
+
+beforeAll(async () => {
+    app = new App();
+    await app.waitForAppReady();
+});
+
+describe("Component Edge Cases and Attribute Handling", () => {
+    describe("Component with standard 'value' attribute", () => {
+        test("should correctly identify and return value property", () => {
+            const comp = new ValueComponent();
+            comp.value = "test value";
+
+            const props = comp.properties();
+            expect(props).toContain("value");
+            expect(props).toHaveLength(1);
+
+            const data = comp.data();
+            expect(data.value).toBe("test value");
+        });
+    });
+
+    describe("Component with custom attribute name", () => {
+        test("should correctly identify and return custom property", () => {
+            const comp = new CustomAttributeComponent();
+            comp.customData = "custom data";
+
+            const props = comp.properties();
+            expect(props).toContain("customData");
+            expect(props).toHaveLength(1);
+
+            const data = comp.data();
+            expect(data.customData).toBe("custom data");
+        });
+    });
+
+    describe("Component with multiple attributes", () => {
+        test("should correctly identify all data properties", () => {
+            const comp = new MultiAttributeComponent();
+            comp.title = "Test Title";
+            comp.content = "Test Content";
+            comp.category = "Test Category";
+
+            const props = comp.properties();
+            expect(props).toContain("title");
+            expect(props).toContain("content");
+            expect(props).toContain("category");
+            expect(props).toHaveLength(3);
+
+            const indexedProps = comp.indexedProperties();
+            expect(indexedProps).toContain("category");
+            expect(indexedProps).toHaveLength(1);
+        });
+
+        test("should return all data in data() method", () => {
+            const comp = new MultiAttributeComponent();
+            comp.title = "Title";
+            comp.content = "Content";
+            comp.category = "Category";
+
+            const data = comp.data();
+            expect(data.title).toBe("Title");
+            expect(data.content).toBe("Content");
+            expect(data.category).toBe("Category");
+        });
+    });
+
+    describe("Component with no data attributes", () => {
+        test("should have empty properties array", () => {
+            const comp = new NoDataComponent();
+
+            const props = comp.properties();
+            expect(props).toHaveLength(0);
+
+            const data = comp.data();
+            expect(Object.keys(data)).toHaveLength(0);
+        });
+    });
+
+    describe("Component with numeric attribute", () => {
+        test("should handle numeric values correctly", () => {
+            const comp = new NumericComponent();
+            comp.count = 42;
+
+            const data = comp.data();
+            expect(data.count).toBe(42);
+            expect(typeof data.count).toBe("number");
+        });
+    });
+
+    describe("Component with boolean attribute", () => {
+        test("should handle boolean values correctly", () => {
+            const comp = new BooleanComponent();
+            comp.enabled = true;
+
+            const data = comp.data();
+            expect(data.enabled).toBe(true);
+            expect(typeof data.enabled).toBe("boolean");
+        });
+    });
+
+    describe("Component update operations", () => {
+        test("should handle partial updates for multi-attribute components", () => {
+            const comp = new MultiAttributeComponent();
+            comp.title = "Initial Title";
+            comp.content = "Initial Content";
+            comp.category = "Initial Category";
+
+            // Simulate partial update
+            comp.title = "Updated Title";
+
+            const data = comp.data();
+            expect(data.title).toBe("Updated Title");
+            expect(data.content).toBe("Initial Content");
+            expect(data.category).toBe("Initial Category");
+        });
+    });
+
+    describe("Component type safety and data integrity", () => {
+        test("should maintain type safety for ComponentDataType", () => {
+            const comp = new ValueComponent();
+            comp.value = "test";
+
+            const data: ComponentDataType<ValueComponent> = comp.data();
+            expect(data.value).toBe("test");
+            // TypeScript should prevent accessing non-existent properties
+            // This test ensures the type system works correctly
+        });
+
+        test("should exclude non-data properties from data()", () => {
+            const comp = new ValueComponent();
+            comp.value = "test";
+            // id is not a data property
+            comp.id = "some-id";
+
+            const data = comp.data();
+            expect(data.value).toBe("test");
+            expect((data as any).id).toBeUndefined();
+        });
+    });
+
+    describe("Component registry and type identification", () => {
+        test("should generate unique type IDs for different components", () => {
+            const comp1 = new ValueComponent();
+            const comp2 = new CustomAttributeComponent();
+
+            expect(comp1.getTypeID()).not.toBe(comp2.getTypeID());
+        });
+    });
+
+    describe("Error handling for malformed components", () => {
+        test("should handle components with undefined values gracefully", () => {
+            const comp = new ValueComponent();
+            // value is undefined initially
+
+            const data = comp.data();
+            expect(data.value).toBe(""); // Default value
+        });
+    });
+});
+
+describe("Component Removal from Entities", () => {
+    test("should successfully remove an existing component from an entity", () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "test" });
+
+        // Verify component is added
+        expect(entity.componentList()).toHaveLength(1);
+        expect(entity.componentList()[0]).toBeInstanceOf(ValueComponent);
+
+        // Remove the component
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(true);
+
+        // Verify component is removed
+        expect(entity.componentList()).toHaveLength(0);
+    });
+
+    test("should return false when trying to remove a non-existent component", () => {
+        const entity = Entity.Create();
+
+        // Try to remove a component that was never added
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(false);
+
+        // Entity should still have no components
+        expect(entity.componentList()).toHaveLength(0);
+    });
+
+    test("should remove only the specified component type, leaving others intact", () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "value comp" });
+        entity.add(CustomAttributeComponent, { customData: "custom comp" });
+
+        // Verify both components are added
+        expect(entity.componentList()).toHaveLength(2);
+
+        // Remove only the ValueComponent
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(true);
+
+        // Verify only CustomAttributeComponent remains
+        expect(entity.componentList()).toHaveLength(1);
+        expect(entity.componentList()[0]).toBeInstanceOf(CustomAttributeComponent);
+    });
+
+    test("should mark entity as dirty after component removal", () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "test" });
+
+        // Entity should be dirty after adding
+        expect((entity as any)._dirty).toBe(true);
+
+        // Save to make it clean
+        // Note: We can't actually save without database, but we can set it manually for test
+        entity.setDirty(false);
+        expect((entity as any)._dirty).toBe(false);
+
+        // Remove component
+        entity.remove(ValueComponent);
+
+        // Entity should be dirty again
+        expect((entity as any)._dirty).toBe(true);
+    });
+
+    test("should persist component addition and removal to database", async () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "test value" });
+
+        // Save to database
+        const saveResult = await entity.save();
+        expect(saveResult).toBe(true);
+
+        // Verify component exists in database
+        const componentsAfterAdd = await db`SELECT id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterAdd.length).toBe(1);
+        expect(componentsAfterAdd[0].data.value).toBe("test value");
+
+        // Remove the component
+        const removed = entity.remove(ValueComponent);
+        expect(removed).toBe(true);
+
+        // Save again to persist removal
+        const saveResult2 = await entity.save();
+        expect(saveResult2).toBe(true);
+
+        // Verify component is removed from database
+        const componentsAfterRemove = await db`SELECT id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterRemove.length).toBe(0);
+    });
+
+    test("should handle multiple component additions and removals in database", async () => {
+        const entity = Entity.Create();
+        entity.add(ValueComponent, { value: "value comp" });
+        entity.add(CustomAttributeComponent, { customData: "custom comp" });
+
+        // Save to database
+        await entity.save();
+
+        // Verify both components exist
+        const componentsAfterAdd = await db`SELECT type_id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL ORDER BY type_id`;
+        expect(componentsAfterAdd.length).toBe(2);
+        const valueComp = componentsAfterAdd.find((c: any) => c.data.value === "value comp");
+        const customComp = componentsAfterAdd.find((c: any) => c.data.customData === "custom comp");
+        expect(valueComp).toBeDefined();
+        expect(customComp).toBeDefined();
+
+        // Remove one component
+        entity.remove(ValueComponent);
+        await entity.save();
+
+        // Verify only custom component remains
+        const componentsAfterRemove = await db`SELECT type_id, data FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterRemove.length).toBe(1);
+        expect(componentsAfterRemove[0].data.customData).toBe("custom comp");
+
+        // Remove the last component
+        entity.remove(CustomAttributeComponent);
+        await entity.save();
+
+        // Verify no components remain
+        const componentsAfterRemoveAll = await db`SELECT id FROM components WHERE entity_id = ${entity.id} AND deleted_at IS NULL`;
+        expect(componentsAfterRemoveAll.length).toBe(0);
+    });
+});

package/tests/errorHandling.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect } from "bun:test";
+import { createUserFriendlyError, handleGraphQLError } from "../core/ErrorHandler";
+import { getErrorMessage, mapZodPathToErrorCode } from "../utils/errorMessages";
+import { GraphQLError } from "graphql";
+import * as z from "zod";
+
+describe('Error Handling Phase 1 Tests', () => {
+    describe('User-Friendly Error Messages', () => {
+        test('should return correct error message for known error code', () => {
+            const errorInfo = getErrorMessage('INVALID_EMAIL');
+            expect(errorInfo.userMessage).toBe('Please enter a valid email address');
+            expect(errorInfo.suggestion).toBe('Check that your email follows the format: name@example.com');
+            expect(errorInfo.category).toBe('validation');
+        });
+
+        test('should return fallback message for unknown error code', () => {
+            const errorInfo = getErrorMessage('UNKNOWN_CODE');
+            expect(errorInfo.userMessage).toBe('An unexpected error occurred');
+            expect(errorInfo.category).toBe('system');
+        });
+
+        test('should map Zod paths to error codes correctly', () => {
+            expect(mapZodPathToErrorCode(['email'])).toBe('INVALID_EMAIL');
+            expect(mapZodPathToErrorCode(['password'])).toBe('TOO_SHORT');
+            expect(mapZodPathToErrorCode(['unknownField'])).toBe('INVALID_FORMAT');
+        });
+    });
+
+    describe('createUserFriendlyError function', () => {
+        test('should create GraphQL error with user-friendly message', () => {
+            const error = createUserFriendlyError('INVALID_EMAIL');
+
+            expect(error).toBeInstanceOf(GraphQLError);
+            expect(error.message).toBe('Please enter a valid email address');
+            expect(error.extensions).toEqual({
+                code: 'INVALID_EMAIL',
+                category: 'validation',
+                suggestion: 'Check that your email follows the format: name@example.com',
+                userFriendly: true
+            });
+        });
+
+        test('should allow custom message override', () => {
+            const customMessage = 'Custom email error';
+            const error = createUserFriendlyError('INVALID_EMAIL', customMessage);
+
+            expect(error.message).toBe(customMessage);
+            expect(error.extensions?.code).toBe('INVALID_EMAIL');
+        });
+
+        test('should merge additional extensions', () => {
+            const error = createUserFriendlyError('INVALID_EMAIL', undefined, {
+                extensions: { additionalField: 'test' }
+            });
+
+            expect(error.extensions?.additionalField).toBe('test');
+            expect(error.extensions?.userFriendly).toBe(true);
+        });
+    });
+
+    describe('handleGraphQLError function', () => {
+        test('should handle Zod validation errors with user-friendly messages', () => {
+            // Create a real Zod error by validating invalid data with a field name
+            const userSchema = z.object({
+                email: z.string().email()
+            });
+            let zodError: z.ZodError;
+
+            try {
+                userSchema.parse({ email: 'invalid-email' });
+            } catch (error) {
+                zodError = error as z.ZodError;
+            }
+
+            expect(() => handleGraphQLError(zodError!)).toThrow(GraphQLError);
+
+            try {
+                handleGraphQLError(zodError!);
+            } catch (error: any) {
+                expect(error.message).toBe('Please enter a valid email address');
+                expect(error.extensions?.code).toBe('VALIDATION_ERROR');
+                expect(error.extensions?.category).toBe('validation');
+                expect(error.extensions?.userFriendly).toBe(true);
+                expect(error.extensions?.validationErrors).toBeDefined();
+                expect(error.extensions?.suggestion).toBe('Check that your email follows the format: name@example.com');
+            }
+        });
+
+        test('should handle multiple Zod validation errors', () => {
+            // Create a schema that will produce multiple validation errors
+            const userSchema = z.object({
+                email: z.string().email(),
+                password: z.string().min(8)
+            });
+
+            let zodError: z.ZodError;
+
+            try {
+                userSchema.parse({
+                    email: 'invalid-email',
+                    password: 'short'
+                });
+            } catch (error) {
+                zodError = error as z.ZodError;
+            }
+
+            expect(() => handleGraphQLError(zodError!)).toThrow(GraphQLError);
+
+            try {
+                handleGraphQLError(zodError!);
+            } catch (error: any) {
+                expect(error.message).toContain('Please enter a valid email address');
+                expect(error.extensions?.validationErrors).toHaveLength(2);
+            }
+        });
+
+        test('should handle empty Zod errors gracefully', () => {
+            const zodError = new z.ZodError([]);
+
+            expect(() => handleGraphQLError(zodError)).toThrow(GraphQLError);
+
+            try {
+                handleGraphQLError(zodError);
+            } catch (error: any) {
+                expect(error.message).toBe('Validation failed');
+                expect(error.extensions?.code).toBe('VALIDATION_ERROR');
+                expect(error.extensions?.userFriendly).toBe(true);
+            }
+        });
+
+        test('should re-throw existing GraphQL errors', () => {
+            const originalError = new GraphQLError('Original error', {
+                extensions: { code: 'ORIGINAL' }
+            });
+
+            expect(() => handleGraphQLError(originalError)).toThrow(originalError);
+        });
+
+        test('should handle unknown errors with user-friendly message', () => {
+            const unknownError = new Error('Some unknown error');
+
+            expect(() => handleGraphQLError(unknownError)).toThrow(GraphQLError);
+
+            try {
+                handleGraphQLError(unknownError);
+            } catch (error: any) {
+                expect(error.message).toBe('Something went wrong on our end');
+                expect(error.extensions?.code).toBe('INTERNAL_ERROR');
+                expect(error.extensions?.category).toBe('system');
+                expect(error.extensions?.suggestion).toBe('Please try again in a few moments. If the problem persists, contact support');
+                expect(error.extensions?.userFriendly).toBe(true);
+            }
+        });
+    });
+});