@upstart.gg/vite-plugins 0.0.37

package/src/tests/upstart-editor-api.test.ts

@@ -0,0 +1,367 @@
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { UpstartEditorAPI, EditableRegistry } from "../upstart-editor-api";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+
+describe("UpstartEditorAPI", () => {
+  let tempDir: string;
+  let api: UpstartEditorAPI;
+  let registryPath: string;
+
+  beforeEach(async () => {
+    // Create a temporary directory for test files
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "upstart-test-"));
+    registryPath = path.join(tempDir, "registry.json");
+    api = new UpstartEditorAPI(tempDir, registryPath);
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("editText", () => {
+    test("should edit text content at correct offset", async () => {
+      // Create a test source file
+      const sourceContent = `<div>Hello World</div>`;
+      const sourcePath = path.join(tempDir, "test.tsx");
+      await fs.writeFile(sourcePath, sourceContent);
+
+      // Create registry
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 16,
+            originalContent: "Hello World",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      // Edit the text
+      const result = await api.editText("test.tsx:1", "Hello Universe");
+
+      expect(result.success).toBe(true);
+
+      // Verify file was updated
+      const updatedContent = await fs.readFile(sourcePath, "utf-8");
+      expect(updatedContent).toBe("<div>Hello Universe</div>");
+    });
+
+    test("should update registry after edit", async () => {
+      const sourceContent = `<div>Original</div>`;
+      const sourcePath = path.join(tempDir, "test.tsx");
+      await fs.writeFile(sourcePath, sourceContent);
+
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 13,
+            originalContent: "Original",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      await api.editText("test.tsx:1", "Modified");
+
+      // Read updated registry
+      const updatedRegistry = JSON.parse(await fs.readFile(registryPath, "utf-8"));
+      expect(updatedRegistry.elements["test.tsx:1"].originalContent).toBe("Modified");
+    });
+
+    test("should shift subsequent offsets after edit", async () => {
+      const sourceContent = `<div>First</div><span>Second</span>`;
+      const sourcePath = path.join(tempDir, "test.tsx");
+      await fs.writeFile(sourcePath, sourceContent);
+
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 10,
+            originalContent: "First",
+            context: { parentTag: "div" },
+          },
+          "test.tsx:2": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 22,
+            endOffset: 28,
+            originalContent: "Second",
+            context: { parentTag: "span" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      // Edit first element (adding 5 characters: "First" -> "First!!!!!")
+      await api.editText("test.tsx:1", "First!!!!!");
+
+      // Read updated registry
+      const updatedRegistry = JSON.parse(await fs.readFile(registryPath, "utf-8"));
+
+      // Second element offset should have shifted by 5
+      expect(updatedRegistry.elements["test.tsx:2"].startOffset).toBe(27);
+      expect(updatedRegistry.elements["test.tsx:2"].endOffset).toBe(33);
+    });
+
+    test("should fail if element not found", async () => {
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {},
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      const result = await api.editText("nonexistent:1", "New text");
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("not found");
+    });
+
+    test("should fail if element is not text type", async () => {
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "className",
+            startOffset: 5,
+            endOffset: 10,
+            originalContent: "px-4",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      const result = await api.editText("test.tsx:1", "New text");
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("not a text element");
+    });
+
+    test("should find content by search if offset has shifted", async () => {
+      // Simulate a file where content has shifted (e.g., due to manual edit)
+      const sourceContent = `\n\n<div>Hello World</div>`;
+      const sourcePath = path.join(tempDir, "test.tsx");
+      await fs.writeFile(sourcePath, sourceContent);
+
+      // Registry has old offsets (before the newlines were added)
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5, // Old offset (now content is at offset 7)
+            endOffset: 16,
+            originalContent: "Hello World",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      // Should still find and edit the content
+      const result = await api.editText("test.tsx:1", "Hello Universe");
+
+      expect(result.success).toBe(true);
+
+      const updatedContent = await fs.readFile(sourcePath, "utf-8");
+      expect(updatedContent).toBe("\n\n<div>Hello Universe</div>");
+    });
+
+    test("should fail if original content no longer exists", async () => {
+      const sourceContent = `<div>Completely Different</div>`;
+      const sourcePath = path.join(tempDir, "test.tsx");
+      await fs.writeFile(sourcePath, sourceContent);
+
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 16,
+            originalContent: "Hello World",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      const result = await api.editText("test.tsx:1", "New content");
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("not found in file");
+    });
+  });
+
+  describe("editClassName", () => {
+    test("should edit className at correct offset", async () => {
+      const sourceContent = `<div className="px-4 py-2">Hello</div>`;
+      const sourcePath = path.join(tempDir, "test.tsx");
+      await fs.writeFile(sourcePath, sourceContent);
+
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "className",
+            startOffset: 16,
+            endOffset: 24,
+            originalContent: "px-4 py-2",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      const result = await api.editClassName("test.tsx:1", "px-8 py-4 bg-blue-500");
+
+      expect(result.success).toBe(true);
+
+      const updatedContent = await fs.readFile(sourcePath, "utf-8");
+      expect(updatedContent).toBe(`<div className="px-8 py-4 bg-blue-500">Hello</div>`);
+    });
+
+    test("should fail if element is not className type", async () => {
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 10,
+            originalContent: "Hello",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      await fs.writeFile(registryPath, JSON.stringify(registry));
+
+      const result = await api.editClassName("test.tsx:1", "new-class");
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("not a className element");
+    });
+  });
+
+  describe("helper methods", () => {
+    test("getElement should return entry by ID", async () => {
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 10,
+            originalContent: "Hello",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      api.setRegistry(registry);
+
+      const entry = api.getElement("test.tsx:1");
+      expect(entry?.originalContent).toBe("Hello");
+    });
+
+    test("getElementsByType should filter by type", async () => {
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "test.tsx:1": {
+            file: "test.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 10,
+            originalContent: "Hello",
+            context: { parentTag: "div" },
+          },
+          "test.tsx:2": {
+            file: "test.tsx",
+            type: "className",
+            startOffset: 20,
+            endOffset: 25,
+            originalContent: "px-4",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      api.setRegistry(registry);
+
+      const textElements = api.getElementsByType("text");
+      const classElements = api.getElementsByType("className");
+
+      expect(Object.keys(textElements).length).toBe(1);
+      expect(Object.keys(classElements).length).toBe(1);
+      expect(textElements["test.tsx:1"]).toBeDefined();
+      expect(classElements["test.tsx:2"]).toBeDefined();
+    });
+
+    test("getElementsByFile should filter by file", async () => {
+      const registry: EditableRegistry = {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        elements: {
+          "file1.tsx:1": {
+            file: "file1.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 10,
+            originalContent: "Hello",
+            context: { parentTag: "div" },
+          },
+          "file2.tsx:1": {
+            file: "file2.tsx",
+            type: "text",
+            startOffset: 5,
+            endOffset: 10,
+            originalContent: "World",
+            context: { parentTag: "div" },
+          },
+        },
+      };
+      api.setRegistry(registry);
+
+      const file1Elements = api.getElementsByFile("file1.tsx");
+      const file2Elements = api.getElementsByFile("file2.tsx");
+
+      expect(Object.keys(file1Elements).length).toBe(1);
+      expect(Object.keys(file2Elements).length).toBe(1);
+      expect(file1Elements["file1.tsx:1"]).toBeDefined();
+      expect(file2Elements["file2.tsx:1"]).toBeDefined();
+    });
+  });
+});