Merge pull request #51 from zackify/copilot/fix-50

Add comprehensive tests for routes and update CI workflow

Author: zackify

******

@@ -21,6 +21,19 @@ jobs:
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
 
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+          
+      - name: Install dependencies
+        run: bun install
+        
+      - name: Run tests
+        env:
+          DATABASE_PATH: ":memory:"
+        run: bun test
+
       - name: Log in to Docker Hub
         uses: docker/login-action@v3
         with:

.github/workflows/docker-publish.yml

@@ -33,3 +33,8 @@ report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
 
 # Finder (MacOS) folder config
 .DS_Store
+
+# SQLite database files
+*.sqlite
+*.sqlite-*
+.aider*

.gitignore

@@ -1,12 +1,41 @@
 import * as sqliteVec from "sqlite-vec";
 import Database from "bun:sqlite";
 
-//macos needs custom path for extension loading
+// macos needs custom path for extension loading
 if (process.env.SQLITE_PATH) {
   Database.setCustomSQLite(process.env.SQLITE_PATH);
 }
 
-export const db = new Database(process.env.DATABASE_PATH || "./data/db.sqlite");
-db.exec("PRAGMA journal_mode = WAL;");
+/**
+ * Get the database instance
+ * This function always returns the current database, 
+ * checking for a test database first, then falling back to the singleton
+ */
+export function getDb(): Database {
+  // For tests, we support injecting a test database instance
+  const testDb = (globalThis as any).testDb;
+  if (testDb) {
+    return testDb;
+  }
+  
+  // For normal operation, create a singleton
+  if (!(globalThis as any)._dbSingleton) {
+    const dbPath = process.env.DATABASE_PATH || "./data/db.sqlite";
+    console.log(`Creating database connection to ${dbPath}`);
+    
+    (globalThis as any)._dbSingleton = new Database(dbPath);
+    (globalThis as any)._dbSingleton.exec("PRAGMA journal_mode = WAL;");
+    sqliteVec.load((globalThis as any)._dbSingleton);
+  }
+  
+  return (globalThis as any)._dbSingleton;
+}
 
-sqliteVec.load(db);
+// Create and export a db proxy that always returns the current database instance
+// This ensures that even code using the imported db directly will get the test db when appropriate
+export const db = new Proxy({} as Database, {
+  get: function(target, prop) {
+    const currentDb = getDb();
+    return currentDb[prop as keyof Database];
+  }
+});

src/database/database.ts

@@ -0,0 +1,138 @@
+import {
+  expect,
+  describe,
+  test,
+  beforeAll,
+  beforeEach,
+  afterAll,
+  mock,
+  spyOn,
+} from "bun:test";
+import Database from "bun:sqlite";
+import * as sqliteVec from "sqlite-vec";
+import { createDocumentsTableSQL } from "../src/database/migrations";
+
+// Set test environment variables
+process.env.DATABASE_PATH = "******"; // In-memory database for tests
+process.env.AI_API_KEY = "test-key";
+process.env.AI_EMBEDDING_MODEL = "test-model";
+
+// Mock for generateEmbeddings
+const mockEmbeddings = Array(1536).fill(0.1);
+const generateEmbeddingsMock = mock(async (text, config) => {
+  return mockEmbeddings;
+});
+
+// Mock the generateEmbeddings module
+mock.module("../src/shared/generateEmbeddings", () => {
+  return {
+    generateEmbeddings: generateEmbeddingsMock,
+  };
+});
+
+// Override the database module before other modules are imported
+describe("Document Route", () => {
+  let db: Database;
+  let documentId: number;
+  
+  // Create a fresh test setup before tests
+  beforeAll(async () => {
+    // Create fresh database
+    db = new Database("******");
+    
+    // Configure database
+    db.exec("PRAGMA journal_mode = WAL;");
+    sqliteVec.load(db);
+    db.exec(createDocumentsTableSQL("1536"));
+    
+    // Spy on database module to return our test db
+    mock.module("../src/database/database", () => ({
+      db: db,
+      getDb: () => db
+    }));
+  });
+  
+  // Insert test data before each test
+  beforeEach(() => {
+    // Clear any existing data
+    db.exec("DELETE FROM documents");
+    
+    // Insert test data
+    const sampleText = "This is a test document for document endpoint";
+    const sampleSource = "test-source";
+    const sampleMetadata = JSON.stringify({ testKey: "testValue" });
+    const embeddingsStr = `[${mockEmbeddings.join(",")}]`;
+    
+    db.query(`
+      INSERT INTO documents (text, metadata, embeddings, source)
+      VALUES (?, ?, ?, ?)
+    `).run(sampleText, sampleMetadata, embeddingsStr, sampleSource);
+    
+    // Get the document id
+    const document = db.query("SELECT id FROM documents LIMIT 1").get() as { id: number } | null;
+    documentId = document?.id || 0;
+  });
+  
+  // Clean up after all tests
+  afterAll(() => {
+    db.close();
+  });
+  
+  test("should retrieve document by id", async () => {
+    // Import the module only after our mock is set up
+    const { document } = await import("../src/routes/document/document");
+    
+    // Get document by ID using the handler function directly
+    const result = await document({ id: documentId });
+    
+    // Verify document properties
+    expect(result).toHaveProperty("document");
+    
+    // Type guard to ensure we're checking the success case
+    if ("document" in result) {
+      const doc = result.document;
+      expect(doc).toHaveProperty("id", documentId);
+      expect(doc).toHaveProperty("text", "This is a test document for document endpoint");
+      expect(doc).toHaveProperty("source", "test-source");
+      expect(doc).toHaveProperty("metadata");
+      expect(doc.metadata).toHaveProperty("testKey", "testValue");
+    } else {
+      // This should not happen in this test, but helps TypeScript
+      throw new Error("Expected document in result but got error");
+    }
+  });
+
+  test("should handle non-existent document id", async () => {
+    // Import the module only after our mock is set up
+    const { document } = await import("../src/routes/document/document");
+    
+    const result = await document({ id: 9999 });
+    
+    // Verify error response
+    expect(result).toHaveProperty("error", "Document not found");
+    expect(result).not.toHaveProperty("document");
+  });
+
+  test("should handle validation errors", async () => {
+    // Import the module only after our mock is set up
+    const { documentRoute } = await import("../src/routes/document/document");
+    
+    // Create request with missing ID
+    const request = new Request("http://localhost/document", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({}),
+    });
+    
+    // Process the request
+    const response = await documentRoute(request);
+    const responseData = await response.json();
+    
+    // Verify validation error
+    expect(response.status).toBe(400);
+    expect(responseData).toHaveProperty("error", "Validation failed");
+    expect(responseData).toHaveProperty("issues");
+  });
+});

tests/documentRoute.test.ts

@@ -6,6 +6,19 @@ import { reembedAllDocuments } from "../src/database/reembedding";
 // Store original environment variables
 const originalEnv = { ...process.env };
 
+// Mock for generateEmbeddings
+const mockEmbeddings = Array(1536).fill(0.1);
+const generateEmbeddingsMock = mock(async (text, config) => {
+  return mockEmbeddings;
+});
+
+// Mock the generateEmbeddings module
+mock.module("../src/shared/generateEmbeddings", () => {
+  return {
+    generateEmbeddings: generateEmbeddingsMock,
+  };
+});
+
 // Helper function to setup mocks for a test
 const setupMocks = (storedModel: string, storedSize: string) => {
   // Create fresh mock for reembedding

tests/embedding-model-change.test.ts

@@ -0,0 +1,69 @@
+import Database from "bun:sqlite";
+import * as sqliteVec from "sqlite-vec";
+import { createDocumentsTableSQL, createDocumentChunksTableSQL } from "../../src/database/migrations";
+
+/**
+ * Creates a fresh in-memory database instance for testing
+ * Each test file should create its own instance to avoid connection issues
+ */
+export function createTestDb() {
+  // Create a new in-memory database
+  const testDb = new Database("******");
+  
+  // Enable WAL mode
+  testDb.exec("PRAGMA journal_mode = WAL;");
+  
+  // Load SQLite vector extension
+  sqliteVec.load(testDb);
+  
+  // Run migrations manually (can't use migration functions directly as they use the global db)
+  testDb.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT UNIQUE NOT NULL,
+      applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+  
+  // Create documents table with 1536 dimensions for OpenAI embeddings
+  testDb.exec(createDocumentsTableSQL("1536"));
+  
+  // Create document chunks table
+  testDb.exec(createDocumentChunksTableSQL("1536"));
+  
+  // Create metadata table
+  testDb.exec(`
+    CREATE TABLE IF NOT EXISTS metadata (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      key TEXT UNIQUE NOT NULL,
+      value TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+  
+  // Insert some initial metadata values that are expected
+  testDb.exec(`
+    INSERT INTO metadata (key, value) VALUES ('AI_EMBEDDING_MODEL', 'text-embedding-ada-002');
+    INSERT INTO metadata (key, value) VALUES ('AI_EMBEDDING_SIZE', '1536');
+  `);
+  
+  return testDb;
+}
+
+/**
+ * Set up the test database as a global for the duration of test execution
+ */
+export function setupTestDb() {
+  const db = createTestDb();
+  (globalThis as any).testDb = db;
+  return db;
+}
+
+/**
+ * Clean up the test database after tests are complete
+ */
+export function teardownTestDb(db: Database) {
+  db.close();
+  delete (globalThis as any).testDb;
+}