neotoma 0.3.0 → 0.3.2

package/tests/integration/mcp_schema_variations.test.ts

@@ -1,428 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { db } from "../../src/db.js";
-import { TestIdTracker } from "../helpers/cleanup_helpers.js";
-
-describe("MCP schema actions - parameter variations", () => {
-  const tracker = new TestIdTracker();
-  const testUserId = "test-user-schema";
-  const testEntityType = `test_type_${Date.now()}`;
-
-  afterEach(async () => {
-    await tracker.cleanup();
-    // Clean up test schemas
-    await db
-      .from("schema_registry")
-      .delete()
-      .eq("entity_type", testEntityType);
-  });
-
-  describe("list_entity_types variations", () => {
-    it("should list all entity types", async () => {
-      const { data: entityTypes } = await db
-        .from("schema_registry")
-        .select("entity_type")
-        .eq("active", true);
-
-      expect(entityTypes).toBeDefined();
-      expect(Array.isArray(entityTypes)).toBe(true);
-    });
-
-    it("should filter entity types by user_id", async () => {
-      // Create user-specific schema
-      await db.from("schema_registry").insert({
-        entity_type: testEntityType,
-        schema_version: "1.0.0",
-        schema_definition: {
-          fields: {
-            title: { type: "string", required: true }
-          }
-        },
-        reducer_config: {
-          merge_policy: "last_write"
-        },
-        active: true,
-        user_id: testUserId
-      });
-
-      const { data: entityTypes } = await db
-        .from("schema_registry")
-        .select("entity_type")
-        .eq("user_id", testUserId);
-
-      expect(entityTypes!.some((et) => et.entity_type === testEntityType)).toBe(true);
-    });
-  });
-
-  describe("register_schema variations", () => {
-    it("should register schema with minimal fields", async () => {
-      const { data: schema } = await db
-        .from("schema_registry")
-        .insert({
-          entity_type: testEntityType,
-          schema_version: "1.0.0",
-          schema_definition: {
-            fields: {
-              title: { type: "string", required: true }
-            }
-          },
-          reducer_config: {
-            merge_policy: "last_write"
-          },
-          active: false
-        })
-        .select()
-        .single();
-
-      expect(schema).toBeDefined();
-      expect(schema!.entity_type).toBe(testEntityType);
-      expect(schema!.active).toBe(false);
-    });
-
-    it("should register schema with all field types", async () => {
-      const { data: schema } = await db
-        .from("schema_registry")
-        .insert({
-          entity_type: `${testEntityType}_all_types`,
-          schema_version: "1.0.0",
-          schema_definition: {
-            fields: {
-              string_field: { type: "string", required: true },
-              number_field: { type: "number", required: false },
-              date_field: { type: "date", required: false },
-              boolean_field: { type: "boolean", required: false },
-              array_field: { type: "array", required: false },
-              object_field: { type: "object", required: false }
-            }
-          },
-          reducer_config: {
-            merge_policy: "last_write"
-          },
-          active: false
-        })
-        .select()
-        .single();
-
-      expect(Object.keys(schema!.schema_definition.fields)).toHaveLength(6);
-    });
-
-    it("should register schema with different reducer strategies", async () => {
-      const strategies = ["last_write", "highest_priority", "most_specific", "merge_array"];
-
-      for (const strategy of strategies) {
-        const { data: schema } = await db
-          .from("schema_registry")
-          .insert({
-            entity_type: `${testEntityType}_${strategy}`,
-            schema_version: "1.0.0",
-            schema_definition: {
-              fields: {
-                title: { type: "string", required: true }
-              }
-            },
-            reducer_config: {
-              merge_policy: strategy
-            },
-            active: false
-          })
-          .select()
-          .single();
-
-        expect(schema!.reducer_config.merge_policy).toBe(strategy);
-
-        // Cleanup
-        await db
-          .from("schema_registry")
-          .delete()
-          .eq("entity_type", `${testEntityType}_${strategy}`);
-      }
-    });
-
-    it("should register user-specific schema", async () => {
-      const { data: schema } = await db
-        .from("schema_registry")
-        .insert({
-          entity_type: `${testEntityType}_user_specific`,
-          schema_version: "1.0.0",
-          schema_definition: {
-            fields: {
-              title: { type: "string", required: true }
-            }
-          },
-          reducer_config: {
-            merge_policy: "last_write"
-          },
-          active: false,
-          user_id: testUserId
-        })
-        .select()
-        .single();
-
-      expect(schema!.user_id).toBe(testUserId);
-
-      // Cleanup
-      await db
-        .from("schema_registry")
-        .delete()
-        .eq("entity_type", `${testEntityType}_user_specific`);
-    });
-
-    it("should register schema with activate: true", async () => {
-      const { data: schema } = await db
-        .from("schema_registry")
-        .insert({
-          entity_type: `${testEntityType}_active`,
-          schema_version: "1.0.0",
-          schema_definition: {
-            fields: {
-              title: { type: "string", required: true }
-            }
-          },
-          reducer_config: {
-            merge_policy: "last_write"
-          },
-          active: true
-        })
-        .select()
-        .single();
-
-      expect(schema!.active).toBe(true);
-
-      // Cleanup
-      await db
-        .from("schema_registry")
-        .delete()
-        .eq("entity_type", `${testEntityType}_active`);
-    });
-
-    it("should register multiple schema versions", async () => {
-      await db.from("schema_registry").insert([
-        {
-          entity_type: `${testEntityType}_versions`,
-          schema_version: "1.0.0",
-          schema_definition: {
-            fields: {
-              title: { type: "string", required: true }
-            }
-          },
-          reducer_config: {
-            merge_policy: "last_write"
-          },
-          active: false
-        },
-        {
-          entity_type: `${testEntityType}_versions`,
-          schema_version: "2.0.0",
-          schema_definition: {
-            fields: {
-              title: { type: "string", required: true },
-              description: { type: "string", required: false }
-            }
-          },
-          reducer_config: {
-            merge_policy: "last_write"
-          },
-          active: true
-        },
-      ]);
-
-      const { data: schemas } = await db
-        .from("schema_registry")
-        .select("*")
-        .eq("entity_type", `${testEntityType}_versions`)
-        .order("schema_version");
-
-      expect(schemas).toHaveLength(2);
-      expect(schemas![0].schema_version).toBe("1.0.0");
-      expect(schemas![1].schema_version).toBe("2.0.0");
-      expect(schemas![1].active).toBe(true);
-
-      // Cleanup
-      await db
-        .from("schema_registry")
-        .delete()
-        .eq("entity_type", `${testEntityType}_versions`);
-    });
-  });
-
-  describe("update_schema_incremental variations", () => {
-    it("should add new fields to existing schema", async () => {
-      // Register initial schema
-      await db.from("schema_registry").insert({
-        entity_type: `${testEntityType}_incremental`,
-        schema_version: "1.0.0",
-        schema_definition: {
-          fields: {
-            title: { type: "string", required: true }
-          }
-        },
-        reducer_config: {
-          merge_policy: "last_write"
-        },
-        active: true
-      });
-
-      // Update with new fields
-      await db.from("schema_registry").insert({
-        entity_type: `${testEntityType}_incremental`,
-        schema_version: "1.1.0",
-        schema_definition: {
-          fields: {
-            title: { type: "string", required: true },
-            description: { type: "string", required: false },
-            tags: { type: "array", required: false }
-          }
-        },
-        reducer_config: {
-          merge_policy: "last_write"
-        },
-        active: true
-      });
-
-      const { data: schema } = await db
-        .from("schema_registry")
-        .select("*")
-        .eq("entity_type", `${testEntityType}_incremental`)
-        .eq("schema_version", "1.1.0")
-        .single();
-
-      expect(Object.keys(schema!.schema_definition.fields)).toHaveLength(3);
-
-      // Cleanup
-      await db
-        .from("schema_registry")
-        .delete()
-        .eq("entity_type", `${testEntityType}_incremental`);
-    });
-
-    it("should update with migrate_existing: false", async () => {
-      // This would be tested at application layer
-      // Here we verify schema can be updated without migration flag
-      await db.from("schema_registry").insert({
-        entity_type: `${testEntityType}_no_migrate`,
-        schema_version: "1.0.0",
-        schema_definition: {
-          fields: {
-            title: { type: "string", required: true }
-          }
-        },
-        reducer_config: {
-          merge_policy: "last_write"
-        },
-        active: true
-      });
-
-      // Cleanup
-      await db
-        .from("schema_registry")
-        .delete()
-        .eq("entity_type", `${testEntityType}_no_migrate`);
-    });
-  });
-
-  describe("analyze_schema_candidates variations", () => {
-    it("should analyze raw_fragments for schema candidates", async () => {
-      // Create test raw_fragments
-      const { data: source, error: sourceError } = await db
-        .from("sources")
-        .insert({
-          user_id: testUserId,
-          content_hash: `schema_analysis_${Date.now()}`,
-          storage_url: "file:///test/minimal.txt",
-          mime_type: "text/plain",
-          file_size: 0
-        })
-        .select()
-        .single();
-
-      expect(sourceError).toBeNull();
-      expect(source).toBeDefined();
-
-      tracker.trackSource(source!.id);
-
-      await db.from("raw_fragments").insert([
-        {
-          source_id: source!.id,
-          entity_type: testEntityType,
-          fragment_key: "new_field_1",
-          fragment_value: "test value 1",
-          fragment_envelope: { inferred_type: "string" },
-          user_id: testUserId,
-        },
-        {
-          source_id: source!.id,
-          entity_type: testEntityType,
-          fragment_key: "new_field_1",
-          fragment_value: "test value 2",
-          fragment_envelope: { inferred_type: "string" },
-          user_id: testUserId,
-        },
-        {
-          source_id: source!.id,
-          entity_type: testEntityType,
-          fragment_key: "new_field_2",
-          fragment_value: "123",
-          fragment_envelope: { inferred_type: "number" },
-          user_id: testUserId,
-        },
-      ]);
-
-      // Analyze would return candidates with frequency > threshold
-      const { data: fragments, error: fragError } = await db
-        .from("raw_fragments")
-        .select("fragment_key, fragment_envelope")
-        .eq("entity_type", testEntityType)
-        .eq("user_id", testUserId);
-
-      expect(fragError).toBeNull();
-      expect(fragments).not.toBeNull();
-      expect(fragments!.length).toBeGreaterThan(0);
-
-      // Cleanup raw_fragments
-      await db
-        .from("raw_fragments")
-        .delete()
-        .eq("entity_type", testEntityType);
-    });
-
-    it("should filter by min_frequency threshold", async () => {
-      // Would be tested at application layer with actual analysis logic
-      const minFrequency = 2;
-      expect(minFrequency).toBeGreaterThan(0);
-    });
-
-    it("should filter by min_confidence threshold", async () => {
-      // Would be tested at application layer with actual analysis logic
-      const minConfidence = 0.8;
-      expect(minConfidence).toBeGreaterThanOrEqual(0);
-      expect(minConfidence).toBeLessThanOrEqual(1);
-    });
-  });
-
-  describe("get_schema_recommendations variations", () => {
-    it("should get recommendations by source: raw_fragments", async () => {
-      // Would be tested at application layer with actual recommendation logic
-      const source = "raw_fragments";
-      expect(["raw_fragments", "agent", "inference", "all"]).toContain(source);
-    });
-
-    it("should get recommendations by status: pending", async () => {
-      // Would be tested at application layer with actual recommendation logic
-      const status = "pending";
-      expect(["pending", "approved", "rejected"]).toContain(status);
-    });
-  });
-
-  describe("health_check_snapshots variations", () => {
-    it("should check for stale snapshots without auto_fix", async () => {
-      // Would be tested at application layer with actual health check logic
-      const autoFix = false;
-      expect(typeof autoFix).toBe("boolean");
-    });
-
-    it("should check for stale snapshots with auto_fix: true", async () => {
-      // Would be tested at application layer with actual health check logic
-      const autoFix = true;
-      expect(typeof autoFix).toBe("boolean");
-    });
-  });
-});