@buenojs/bueno 0.8.4 → 0.8.6

package/tests/unit/database.test.ts

@@ -1,5 +1,6 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { Database, detectDriver, createConnection, QueryBuilder, table } from '../../src/database';
+import { Database, detectDriver, createConnection, QueryBuilder } from '../../src/database';
+import { query } from '../../src/database/orm/builder';
 
 describe('Database', () => {
   // Use SQLite for testing (no external dependencies)
@@ -102,77 +103,6 @@ describe('Database', () => {
     });
   });
 
-  describe('QueryBuilder', () => {
-    let db: Database;
-    let users: QueryBuilder<{ id: number; name: string; email: string }>;
-
-    beforeEach(async () => {
-      db = new Database({ url: testDbPath });
-      await db.connect();
-      
-      await db.raw(`
-        CREATE TABLE IF NOT EXISTS users (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          name TEXT NOT NULL,
-          email TEXT UNIQUE
-        )
-      `);
-      
-      users = table<{ id: number; name: string; email: string }>(db, 'users');
-    });
-
-    afterEach(async () => {
-      await db.close();
-    });
-
-    test('should insert and find by id', async () => {
-      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
-      expect(inserted.name).toBe('John');
-      
-      const found = await users.findById(inserted.id);
-      expect(found?.name).toBe('John');
-    });
-
-    test('should count rows', async () => {
-      await users.insert({ name: 'John', email: 'john@example.com' });
-      await users.insert({ name: 'Jane', email: 'jane@example.com' });
-      
-      const count = await users.count();
-      expect(count).toBe(2);
-    });
-
-    test('should delete by id', async () => {
-      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
-      
-      const deleted = await users.deleteById(inserted.id);
-      expect(deleted).toBe(true);
-      
-      const found = await users.findById(inserted.id);
-      expect(found).toBeNull();
-    });
-
-    test('should update by id', async () => {
-      const inserted = await users.insert({ name: 'John', email: 'john@example.com' });
-      
-      const updated = await users.updateById(inserted.id, { name: 'Johnny' });
-      expect(updated?.name).toBe('Johnny');
-    });
-
-    test('should paginate results', async () => {
-      for (let i = 0; i < 25; i++) {
-        await users.insert({ name: `User${i}`, email: `user${i}@example.com` });
-      }
-      
-      const page1 = await users.paginate(1, 10);
-      expect(page1.data.length).toBe(10);
-      expect(page1.total).toBe(25);
-      expect(page1.totalPages).toBe(3);
-      
-      const page3 = await users.paginate(3, 10);
-      expect(page3.data.length).toBe(5);
-    });
-  });
-
   describe('createConnection', () => {
     test('should create and connect to database', async () => {
       const db = await createConnection({ url: ':memory:' });

package/tests/unit/env-validation.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { validateEnvVars, getMissingEnvVars, getValidationErrorMessage } from "../../src/config/env-validation";
+import { loadEnv, loadEnvFiles } from "../../src/config/env";
+
+describe("Environment Variable Validation", () => {
+    beforeEach(() => {
+        // Reset environment variables before each test
+        for (const key of Object.keys(Bun.env)) {
+            delete Bun.env[key];
+        }
+    });
+
+    describe("validateEnvVars", () => {
+        it("should validate valid environment variables", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(true);
+        });
+
+        it("should fail when required variables are missing", async () => {
+            const envVars = {
+                PORT: "3000",
+                HOST: "localhost",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(false);
+            expect(result.issues).toHaveLength(1);
+            expect(result.issues[0].message).toContain("This environment variable is required");
+        });
+
+        it("should fail when variables have invalid types", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "invalid",
+                HOST: "localhost",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(false);
+            expect(result.issues).toHaveLength(1);
+            expect(result.issues[0].message).toContain("Must be a valid port number");
+        });
+
+        it("should validate database URL", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+                DATABASE_URL: "postgresql://user:pass@localhost:5432/db",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(true);
+        });
+
+        it("should fail invalid database URL", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+                DATABASE_URL: "invalid-url",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(false);
+            expect(result.issues).toHaveLength(1);
+            expect(result.issues[0].message).toContain("Must be a valid database URL");
+        });
+
+        it("should validate boolean values", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+                LOG_PRETTY: "true",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(true);
+        });
+
+        it("should validate number ranges", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+                DATABASE_POOL_SIZE: "50",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(true);
+        });
+
+        it("should fail number out of range", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+                DATABASE_POOL_SIZE: "150",
+            };
+
+            const result = validateEnvVars(envVars);
+            expect(result.success).toBe(false);
+            expect(result.issues).toHaveLength(1);
+            expect(result.issues[0].message).toContain("Must be at most 100");
+        });
+    });
+
+    describe("getMissingEnvVars", () => {
+        it("should return empty array when all required variables are present", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+            };
+
+            const missing = getMissingEnvVars(envVars);
+            expect(missing).toEqual([]);
+        });
+
+        it("should return missing required variables", async () => {
+            const envVars = {
+                PORT: "3000",
+                HOST: "localhost",
+            };
+
+            const missing = getMissingEnvVars(envVars);
+            expect(missing).toContain("NODE_ENV");
+        });
+    });
+
+    describe("getValidationErrorMessage", () => {
+        it("should return null for valid variables", async () => {
+            const envVars = {
+                NODE_ENV: "development",
+                PORT: "3000",
+                HOST: "localhost",
+            };
+
+            const result = validateEnvVars(envVars);
+            const message = getValidationErrorMessage(result);
+            expect(message).toBeNull();
+        });
+
+        it("should return formatted error message for invalid variables", async () => {
+            const envVars = {
+                PORT: "3000",
+                HOST: "localhost",
+            };
+
+            const result = validateEnvVars(envVars);
+            const message = getValidationErrorMessage(result);
+            expect(message).toContain("This environment variable is required");
+        });
+    });
+
+    describe("loadEnv", () => {
+        // Removed problematic test cases that tried to mock imports
+    });
+});