ahok-skill 1.3.1

package/tests/test_api_workspace_management.ts

@@ -0,0 +1,413 @@
+/**
+ * Extensive API Tests for Memory Workspace Management
+ * Tests the deployed backend endpoints via HTTP
+ */
+
+// Configuration - update this to your deployed API URL
+const API_URL = process.env.API_URL || "https://zqmt62peqz.us-east-1.awsapprunner.com";
+const API_KEY = process.env.API_KEY || "napi_ce3w2t2k6vjmms1j7hnc8j0o0owgje9t65opzmp8cc3b6tr4nyxnhi2lun7lc90f";
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+let testWorkspaceIds: string[] = [];
+let testMemoryIds: string[] = [];
+
+async function apiRequest(method: string, path: string, body?: any): Promise<{ status: number; data: any }> {
+    const url = `${API_URL}${path}`;
+    const options: RequestInit = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": API_KEY,
+        },
+    };
+    
+    if (body) {
+        options.body = JSON.stringify(body);
+    }
+    
+    try {
+        const response = await fetch(url, options);
+        const data = await response.json().catch(() => ({}));
+        return { status: response.status, data };
+    } catch (error: any) {
+        return { status: 0, data: { error: error.message } };
+    }
+}
+
+async function setup() {
+    console.log("=".repeat(70));
+    console.log("Extensive API Tests for Memory Workspace Management");
+    console.log("=".repeat(70));
+    console.log(`\nAPI URL: ${API_URL}`);
+    console.log(`API Key: ${API_KEY.substring(0, 20)}...`);
+}
+
+/**
+ * Test 0: Health check
+ */
+async function test_health_check() {
+    console.log("\n[Test 0] Health Check...");
+    
+    const { status } = await apiRequest("GET", "/health");
+    if (status === 200) {
+        console.log("  ✓ API is healthy");
+    } else {
+        console.log(`  ⚠ Health check returned status ${status} (continuing anyway)`);
+    }
+}
+
+/**
+ * Test 1: Create workspaces via POST /keys
+ */
+async function test_create_workspaces() {
+    console.log("\n[Test 1] Creating workspaces via POST /keys...");
+    
+    const workspaces = [
+        { label: "Test-Development" },
+        { label: "Test-Production" },
+        { label: "Test-Staging" },
+    ];
+    
+    for (const ws of workspaces) {
+        const { status, data } = await apiRequest("POST", "/keys", ws);
+        
+        if (status === 200 && data.id) {
+            testWorkspaceIds.push(data.id);
+            console.log(`  ✓ Created workspace: ${ws.label} (${data.id})`);
+            console.log(`    Secret key: ${data.secret_key?.substring(0, 25)}...`);
+        } else {
+            throw new Error(`Failed to create workspace: ${status} ${JSON.stringify(data)}`);
+        }
+    }
+    
+    console.log(`  ✓ Total workspaces created: ${testWorkspaceIds.length}`);
+}
+
+/**
+ * Test 2: List workspaces via GET /keys
+ */
+async function test_list_workspaces() {
+    console.log("\n[Test 2] Listing workspaces via GET /keys...");
+    
+    const { status, data } = await apiRequest("GET", "/keys");
+    
+    if (status !== 200) {
+        throw new Error(`Failed to list workspaces: ${status} ${JSON.stringify(data)}`);
+    }
+    
+    const keys = data.keys || [];
+    console.log(`  ✓ Found ${keys.length} workspaces`);
+    
+    // Verify our test workspaces exist
+    const foundIds = keys.map((k: any) => k.id);
+    for (const id of testWorkspaceIds) {
+        if (!foundIds.includes(id)) {
+            throw new Error(`Workspace ${id} not found in list`);
+        }
+    }
+    
+    console.log("  ✓ All test workspaces found in list");
+}
+
+/**
+ * Test 3: Get workspace statistics via GET /keys/stats
+ */
+async function test_workspace_stats_empty() {
+    console.log("\n[Test 3] Getting workspace statistics (empty) via GET /keys/stats...");
+    
+    const { status, data } = await apiRequest("GET", "/keys/stats");
+    
+    if (status !== 200) {
+        throw new Error(`Failed to get stats: ${status} ${JSON.stringify(data)}`);
+    }
+    
+    const workspaces = data.workspaces || [];
+    console.log(`  ✓ Stats returned for ${workspaces.length} workspaces`);
+    
+    // Verify memory counts are 0 for new workspaces
+    for (const ws of workspaces) {
+        if (testWorkspaceIds.includes(ws.id)) {
+            console.log(`    ${ws.label}: ${ws.memory_count} memories`);
+        }
+    }
+    
+    console.log("  ✓ Workspace statistics retrieved successfully");
+}
+
+/**
+ * Test 4: Rename workspace via PATCH /keys/:id
+ */
+async function test_rename_workspace() {
+    console.log("\n[Test 4] Renaming workspace via PATCH /keys/:id...");
+    
+    const workspaceId = testWorkspaceIds[0];
+    const newLabel = "Test-Development-RENAMED";
+    
+    const { status, data } = await apiRequest("PATCH", `/keys/${workspaceId}`, { label: newLabel });
+    
+    if (status !== 200) {
+        throw new Error(`Failed to rename workspace: ${status} ${JSON.stringify(data)}`);
+    }
+    
+    if (data.label !== newLabel) {
+        throw new Error(`Rename failed: expected "${newLabel}", got "${data.label}"`);
+    }
+    
+    console.log(`  ✓ Workspace renamed to: ${newLabel}`);
+    console.log(`  ✓ Updated at: ${new Date(data.updated_at).toISOString()}`);
+}
+
+/**
+ * Test 5: Rename validation - empty label should fail
+ */
+async function test_rename_validation() {
+    console.log("\n[Test 5] Testing rename validation (empty label)...");
+    
+    const workspaceId = testWorkspaceIds[0];
+    
+    // Test empty string
+    let { status } = await apiRequest("PATCH", `/keys/${workspaceId}`, { label: "" });
+    
+    if (status === 400) {
+        console.log("  ✓ Empty label correctly rejected with 400");
+    } else {
+        console.log(`  ⚠ Expected 400 for empty label, got ${status}`);
+    }
+    
+    // Test whitespace only
+    ({ status } = await apiRequest("PATCH", `/keys/${workspaceId}`, { label: "   " }));
+    
+    if (status === 400) {
+        console.log("  ✓ Whitespace-only label correctly rejected with 400");
+    } else {
+        console.log(`  ⚠ Expected 400 for whitespace label, got ${status}`);
+    }
+}
+
+/**
+ * Test 6: Create memories in workspaces via POST /memory/add
+ * Note: Using memory_key_id in body (requires updated backend) or workspace secret key
+ */
+async function test_create_memories() {
+    console.log("\n[Test 6] Creating memories in workspaces via POST /memory/add...");
+    
+    const memories = [
+        { content: "Test memory 1 in Development workspace - unique " + Date.now(), workspace_idx: 0 },
+        { content: "Test memory 2 in Development workspace - unique " + Date.now(), workspace_idx: 0 },
+        { content: "Test memory 3 in Production workspace - unique " + Date.now(), workspace_idx: 1 },
+        { content: "Test memory 4 in Production workspace - unique " + Date.now(), workspace_idx: 1 },
+        { content: "Test memory 5 in Production workspace - unique " + Date.now(), workspace_idx: 1 },
+        { content: "Test memory 6 in Staging workspace - unique " + Date.now(), workspace_idx: 2 },
+    ];
+    
+    for (const mem of memories) {
+        // Try with memory_key_id in body (works with updated backend)
+        const { status, data } = await apiRequest("POST", "/memory/add", {
+            content: mem.content,
+            memory_key_id: testWorkspaceIds[mem.workspace_idx]
+        });
+        
+        if (status === 200 && data.id) {
+            testMemoryIds.push(data.id);
+            console.log(`  ✓ Created memory: ${data.id.substring(0, 8)}... in workspace ${mem.workspace_idx + 1}`);
+        } else {
+            console.log(`  ⚠ Failed to create memory: ${status} ${JSON.stringify(data)}`);
+        }
+        
+        await sleep(300); // Small delay between creates
+    }
+    
+    console.log(`  ✓ Total memories created: ${testMemoryIds.length}`);
+}
+
+/**
+ * Test 7: Verify workspace statistics with memories
+ */
+async function test_workspace_stats_with_memories() {
+    console.log("\n[Test 7] Verifying workspace statistics with memories...");
+    
+    await sleep(1000); // Wait for indexing
+    
+    const { status, data } = await apiRequest("GET", "/keys/stats");
+    
+    if (status !== 200) {
+        throw new Error(`Failed to get stats: ${status}`);
+    }
+    
+    const workspaces = data.workspaces || [];
+    const statsMap = new Map<string, number>();
+    
+    for (const ws of workspaces) {
+        if (testWorkspaceIds.includes(ws.id)) {
+            statsMap.set(ws.id, ws.memory_count);
+            console.log(`  ${ws.label}: ${ws.memory_count} memories`);
+        }
+    }
+    
+    // Expected: ws1=2, ws2=3, ws3=1
+    const ws1Count = statsMap.get(testWorkspaceIds[0]) || 0;
+    const ws2Count = statsMap.get(testWorkspaceIds[1]) || 0;
+    const ws3Count = statsMap.get(testWorkspaceIds[2]) || 0;
+    
+    console.log(`  Expected: Development=2, Production=3, Staging=1`);
+    console.log(`  Actual: Development=${ws1Count}, Production=${ws2Count}, Staging=${ws3Count}`);
+    
+    if (ws1Count === 2 && ws2Count === 3 && ws3Count === 1) {
+        console.log("  ✓ All memory counts are correct!");
+    } else {
+        console.log("  ⚠ Memory counts don't match expected values (may need more time for indexing)");
+    }
+}
+
+/**
+ * Test 8: Bulk move memories via POST /memory/bulk-move
+ */
+async function test_bulk_move() {
+    console.log("\n[Test 8] Testing bulk move via POST /memory/bulk-move...");
+    
+    if (testMemoryIds.length < 2) {
+        console.log("  ⚠ Not enough memories to test bulk move");
+        return;
+    }
+    
+    // Move first 2 memories (from Development) to Staging
+    const idsToMove = testMemoryIds.slice(0, 2);
+    const targetWorkspace = testWorkspaceIds[2]; // Staging
+    
+    console.log(`  Moving ${idsToMove.length} memories to Staging workspace...`);
+    
+    const { status, data } = await apiRequest("POST", "/memory/bulk-move", {
+        ids: idsToMove,
+        target_workspace_id: targetWorkspace
+    });
+    
+    console.log(`  Response: ${status} - moved: ${data.moved}, failed: ${data.failed?.length || 0}`);
+    
+    if (status === 200 || status === 207) {
+        console.log(`  ✓ Bulk move completed: ${data.moved} moved`);
+        
+        // Verify by checking stats
+        await sleep(500);
+        const statsRes = await apiRequest("GET", "/keys/stats");
+        
+        if (statsRes.status === 200) {
+            const workspaces = statsRes.data.workspaces || [];
+            for (const ws of workspaces) {
+                if (testWorkspaceIds.includes(ws.id)) {
+                    console.log(`    ${ws.label}: ${ws.memory_count} memories`);
+                }
+            }
+        }
+    } else {
+        console.log(`  ⚠ Bulk move failed: ${JSON.stringify(data)}`);
+    }
+}
+
+/**
+ * Test 9: Bulk delete memories via POST /memory/bulk-delete
+ */
+async function test_bulk_delete() {
+    console.log("\n[Test 9] Testing bulk delete via POST /memory/bulk-delete...");
+    
+    if (testMemoryIds.length < 2) {
+        console.log("  ⚠ Not enough memories to test bulk delete");
+        return;
+    }
+    
+    // Delete last 2 memories
+    const idsToDelete = testMemoryIds.slice(-2);
+    
+    console.log(`  Deleting ${idsToDelete.length} memories...`);
+    
+    const { status, data } = await apiRequest("POST", "/memory/bulk-delete", {
+        ids: idsToDelete
+    });
+    
+    console.log(`  Response: ${status} - deleted: ${data.deleted}, failed: ${data.failed?.length || 0}`);
+    
+    if (status === 200 || status === 207) {
+        console.log(`  ✓ Bulk delete completed: ${data.deleted} deleted`);
+        
+        // Remove from our tracking array
+        testMemoryIds = testMemoryIds.slice(0, -2);
+    } else {
+        console.log(`  ⚠ Bulk delete failed: ${JSON.stringify(data)}`);
+    }
+}
+
+/**
+ * Test 10: Delete workspace via DELETE /keys/:id
+ */
+async function test_delete_workspace() {
+    console.log("\n[Test 10] Deleting workspace via DELETE /keys/:id...");
+    
+    const workspaceId = testWorkspaceIds[2]; // Delete Staging
+    
+    const { status, data } = await apiRequest("DELETE", `/keys/${workspaceId}`);
+    
+    if (status === 200) {
+        console.log(`  ✓ Workspace deleted successfully`);
+        testWorkspaceIds = testWorkspaceIds.filter(id => id !== workspaceId);
+    } else {
+        console.log(`  ⚠ Delete failed: ${status} ${JSON.stringify(data)}`);
+    }
+}
+
+/**
+ * Cleanup: Delete all test data
+ */
+async function cleanup() {
+    console.log("\n[Cleanup] Removing test data...");
+    
+    // Delete remaining memories
+    if (testMemoryIds.length > 0) {
+        console.log(`  Deleting ${testMemoryIds.length} remaining memories...`);
+        await apiRequest("POST", "/memory/bulk-delete", { ids: testMemoryIds });
+    }
+    
+    // Delete remaining workspaces
+    for (const id of testWorkspaceIds) {
+        await apiRequest("DELETE", `/keys/${id}`);
+    }
+    
+    console.log("  ✓ Cleanup complete");
+}
+
+async function run_all_tests() {
+    try {
+        await setup();
+        await test_health_check();
+        await test_create_workspaces();
+        await test_list_workspaces();
+        await test_workspace_stats_empty();
+        await test_rename_workspace();
+        await test_rename_validation();
+        await test_create_memories();
+        await test_workspace_stats_with_memories();
+        await test_bulk_move();
+        await test_bulk_delete();
+        await test_delete_workspace();
+        await cleanup();
+        
+        console.log("\n" + "=".repeat(70));
+        console.log("✅ ALL API TESTS COMPLETED SUCCESSFULLY");
+        console.log("=".repeat(70));
+        process.exit(0);
+    } catch (error: any) {
+        console.error("\n" + "=".repeat(70));
+        console.error("❌ TEST FAILED:", error.message);
+        console.error("=".repeat(70));
+        
+        // Attempt cleanup
+        try {
+            await cleanup();
+        } catch (e) {
+            console.error("Cleanup also failed:", e);
+        }
+        
+        process.exit(1);
+    }
+}
+
+run_all_tests();

package/tests/test_bulk_delete.ts

@@ -0,0 +1,267 @@
+/**
+ * Unit tests for POST /memory/bulk-delete endpoint
+ * Requirements: 6.2, 6.3
+ */
+
+import { q, run_async, vector_store } from "../src/core/db";
+import { add_hsg_memory } from "../src/memory/hsg";
+import { j } from "../src/utils";
+
+// Force synthetic embeddings for reliability
+process.env.OM_EMBEDDINGS = "synthetic";
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function cleanup(user_id: string) {
+    await run_async(`DELETE FROM memories WHERE user_id = '${user_id}'`);
+    try { await run_async(`DELETE FROM vectors`); } catch { }
+    try { await run_async(`DELETE FROM openmemory_vectors`); } catch { }
+    try { await run_async(`DELETE FROM waypoints`); } catch { }
+    if (global.gc) global.gc();
+}
+
+/**
+ * Test: Bulk delete successfully removes all specified memories
+ * Validates: Requirement 6.2 - Backend_API SHALL delete all selected memories
+ */
+async function test_bulk_delete_success() {
+    console.log("\n[Test 1] Bulk Delete - All Memories Deleted Successfully");
+    const uid = "bulk_delete_test_user_1";
+    await cleanup(uid);
+    await sleep(500);
+
+    // Create test memories with unique content to avoid deduplication
+    const timestamp = Date.now();
+    const mem1 = await add_hsg_memory(`Memory 1 for bulk delete - unique ${timestamp}-1`, j([]), {}, uid, null);
+    await sleep(200);
+    const mem2 = await add_hsg_memory(`Memory 2 for bulk delete - unique ${timestamp}-2`, j([]), {}, uid, null);
+    await sleep(200);
+    const mem3 = await add_hsg_memory(`Memory 3 for bulk delete - unique ${timestamp}-3`, j([]), {}, uid, null);
+    
+    await sleep(500);
+
+    // Verify memories exist
+    const before1 = await q.get_mem.get(mem1.id);
+    const before2 = await q.get_mem.get(mem2.id);
+    const before3 = await q.get_mem.get(mem3.id);
+    
+    if (!before1 || !before2 || !before3) {
+        throw new Error("FAIL: Test memories were not created properly");
+    }
+
+    // Perform bulk delete
+    const ids = [mem1.id, mem2.id, mem3.id];
+    const deleted: string[] = [];
+    const failed: string[] = [];
+
+    for (const id of ids) {
+        try {
+            const m = await q.get_mem.get(id);
+            if (!m) {
+                failed.push(id);
+                continue;
+            }
+            if (uid && m.user_id !== uid) {
+                failed.push(id);
+                continue;
+            }
+            await q.del_mem.run(id);
+            await vector_store.deleteVectors(id);
+            await q.del_waypoints.run(id, id);
+            deleted.push(id);
+        } catch (e) {
+            failed.push(id);
+        }
+    }
+
+    // Verify all deleted
+    if (deleted.length !== 3) {
+        throw new Error(`FAIL: Expected 3 deleted, got ${deleted.length}`);
+    }
+    if (failed.length !== 0) {
+        throw new Error(`FAIL: Expected 0 failed, got ${failed.length}`);
+    }
+
+    // Verify memories no longer exist
+    const after1 = await q.get_mem.get(mem1.id);
+    const after2 = await q.get_mem.get(mem2.id);
+    const after3 = await q.get_mem.get(mem3.id);
+
+    if (after1 || after2 || after3) {
+        throw new Error("FAIL: Memories still exist after bulk delete");
+    }
+
+    console.log(` -> Deleted: ${deleted.length}, Failed: ${failed.length}`);
+    console.log(" -> PASS: All memories deleted successfully");
+}
+
+/**
+ * Test: Bulk delete with non-existent IDs reports failures
+ * Validates: Requirement 6.3 - Backend_API SHALL continue deleting remaining memories and report partial success
+ */
+async function test_bulk_delete_partial_failure() {
+    console.log("\n[Test 2] Bulk Delete - Partial Failure with Non-existent IDs");
+    const uid = "bulk_delete_test_user_2";
+    await cleanup(uid);
+    await sleep(500);
+
+    // Create one real memory
+    const mem1 = await add_hsg_memory("Real memory for partial test", j([]), {}, uid, null);
+    await sleep(500);
+
+    // Mix real and fake IDs
+    const ids = [mem1.id, "non-existent-id-1", "non-existent-id-2"];
+    const deleted: string[] = [];
+    const failed: string[] = [];
+
+    for (const id of ids) {
+        try {
+            const m = await q.get_mem.get(id);
+            if (!m) {
+                failed.push(id);
+                continue;
+            }
+            if (uid && m.user_id !== uid) {
+                failed.push(id);
+                continue;
+            }
+            await q.del_mem.run(id);
+            await vector_store.deleteVectors(id);
+            await q.del_waypoints.run(id, id);
+            deleted.push(id);
+        } catch (e) {
+            failed.push(id);
+        }
+    }
+
+    // Verify partial success
+    if (deleted.length !== 1) {
+        throw new Error(`FAIL: Expected 1 deleted, got ${deleted.length}`);
+    }
+    if (failed.length !== 2) {
+        throw new Error(`FAIL: Expected 2 failed, got ${failed.length}`);
+    }
+
+    // Verify the real memory was deleted
+    const after = await q.get_mem.get(mem1.id);
+    if (after) {
+        throw new Error("FAIL: Real memory still exists after bulk delete");
+    }
+
+    console.log(` -> Deleted: ${deleted.length}, Failed: ${failed.length}`);
+    console.log(` -> Failed IDs: ${failed.join(", ")}`);
+    console.log(" -> PASS: Partial failure handled correctly");
+}
+
+/**
+ * Test: Bulk delete with ownership verification
+ * Validates: Requirement 6.2 - Delete each memory with ownership verification
+ */
+async function test_bulk_delete_ownership_verification() {
+    console.log("\n[Test 3] Bulk Delete - Ownership Verification");
+    const uid1 = "bulk_delete_owner_1";
+    const uid2 = "bulk_delete_owner_2";
+    await cleanup(uid1);
+    await cleanup(uid2);
+    await sleep(500);
+
+    // Create memories for different users
+    const mem1 = await add_hsg_memory("Memory owned by user 1", j([]), {}, uid1, null);
+    const mem2 = await add_hsg_memory("Memory owned by user 2", j([]), {}, uid2, null);
+    await sleep(500);
+
+    // Try to delete both as user 1
+    const ids = [mem1.id, mem2.id];
+    const deleted: string[] = [];
+    const failed: string[] = [];
+
+    for (const id of ids) {
+        try {
+            const m = await q.get_mem.get(id);
+            if (!m) {
+                failed.push(id);
+                continue;
+            }
+            // Check ownership - user 1 trying to delete
+            if (uid1 && m.user_id !== uid1) {
+                failed.push(id);
+                continue;
+            }
+            await q.del_mem.run(id);
+            await vector_store.deleteVectors(id);
+            await q.del_waypoints.run(id, id);
+            deleted.push(id);
+        } catch (e) {
+            failed.push(id);
+        }
+    }
+
+    // User 1 should only be able to delete their own memory
+    if (deleted.length !== 1) {
+        throw new Error(`FAIL: Expected 1 deleted (own memory), got ${deleted.length}`);
+    }
+    if (failed.length !== 1) {
+        throw new Error(`FAIL: Expected 1 failed (other user's memory), got ${failed.length}`);
+    }
+
+    // Verify user 1's memory was deleted
+    const after1 = await q.get_mem.get(mem1.id);
+    if (after1) {
+        throw new Error("FAIL: User 1's memory still exists");
+    }
+
+    // Verify user 2's memory still exists
+    const after2 = await q.get_mem.get(mem2.id);
+    if (!after2) {
+        throw new Error("FAIL: User 2's memory was incorrectly deleted");
+    }
+
+    console.log(` -> Deleted: ${deleted.length}, Failed: ${failed.length}`);
+    console.log(" -> PASS: Ownership verification working correctly");
+
+    // Cleanup user 2's memory
+    await cleanup(uid2);
+}
+
+/**
+ * Test: Bulk delete with empty array
+ */
+async function test_bulk_delete_empty_array() {
+    console.log("\n[Test 4] Bulk Delete - Empty Array");
+    
+    const ids: string[] = [];
+    const deleted: string[] = [];
+    const failed: string[] = [];
+
+    // Empty array should return immediately with 0 deleted
+    for (const id of ids) {
+        // This loop won't execute
+        deleted.push(id);
+    }
+
+    if (deleted.length !== 0) {
+        throw new Error(`FAIL: Expected 0 deleted for empty array, got ${deleted.length}`);
+    }
+    if (failed.length !== 0) {
+        throw new Error(`FAIL: Expected 0 failed for empty array, got ${failed.length}`);
+    }
+
+    console.log(` -> Deleted: ${deleted.length}, Failed: ${failed.length}`);
+    console.log(" -> PASS: Empty array handled correctly");
+}
+
+async function run_all() {
+    try {
+        await test_bulk_delete_success();
+        await test_bulk_delete_partial_failure();
+        await test_bulk_delete_ownership_verification();
+        await test_bulk_delete_empty_array();
+        console.log("\n[BULK DELETE TESTS] ALL TESTS PASSED");
+        process.exit(0);
+    } catch (e) {
+        console.error("\n[BULK DELETE TESTS] TEST FAILED:", e);
+        process.exit(1);
+    }
+}
+
+run_all();