tower-studio 0.1.2 → 0.1.5

package/.next/standalone/tower/tests/unit/lib/note-actions.test.ts

@@ -1,296 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import { PrismaClient } from "@prisma/client";
-
-// Mock next/cache before importing server actions
-vi.mock("next/cache", () => ({
-  revalidatePath: vi.fn(),
-}));
-
-// Use real fts.ts — it operates against the same SQLite DB
-import {
-  createNote,
-  updateNote,
-  deleteNote,
-  getNoteById,
-  getProjectNotes,
-} from "@/actions/note-actions";
-
-const testDb = new PrismaClient({
-  datasources: {
-    db: { url: process.env.DATABASE_URL ?? "file:./prisma/dev.db" },
-  },
-});
-
-let testWorkspaceId: string;
-let testProjectId: string;
-
-beforeAll(async () => {
-  await testDb.$connect();
-
-  // Ensure FTS5 table exists
-  await testDb.$executeRawUnsafe(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts
-    USING fts5(
-      note_id UNINDEXED,
-      title,
-      content,
-      tokenize='trigram case_sensitive 0'
-    )
-  `);
-
-  // Create test workspace and project
-  const workspace = await testDb.workspace.create({
-    data: { name: "Note Actions Test Workspace" },
-  });
-  testWorkspaceId = workspace.id;
-
-  const project = await testDb.project.create({
-    data: {
-      name: "Note Actions Test Project",
-      workspaceId: testWorkspaceId,
-    },
-  });
-  testProjectId = project.id;
-});
-
-afterAll(async () => {
-  // Delete all notes' FTS entries then clean up workspace (cascade)
-  const notes = await testDb.projectNote.findMany({
-    where: { projectId: testProjectId },
-  });
-  for (const n of notes) {
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", n.id);
-  }
-  await testDb.workspace.delete({ where: { id: testWorkspaceId } });
-  await testDb.$disconnect();
-});
-
-describe("createNote", () => {
-  it("creates a note with default category '备忘'", async () => {
-    const note = await createNote({
-      title: "Test Note Default Category",
-      content: "Some content",
-      projectId: testProjectId,
-    });
-
-    expect(note.id).toBeTruthy();
-    expect(note.title).toBe("Test Note Default Category");
-    expect(note.content).toBe("Some content");
-    expect(note.category).toBe("备忘");
-    expect(note.projectId).toBe(testProjectId);
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-    await testDb.projectNote.delete({ where: { id: note.id } });
-  });
-
-  it("creates a note with a custom category", async () => {
-    const note = await createNote({
-      title: "Account Note",
-      content: "Login credentials",
-      category: "账号",
-      projectId: testProjectId,
-    });
-
-    expect(note.category).toBe("账号");
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-    await testDb.projectNote.delete({ where: { id: note.id } });
-  });
-
-  it("syncs note to FTS after creation", async () => {
-    const note = await createNote({
-      title: "FTS Sync Test Note",
-      content: "Should appear in FTS",
-      projectId: testProjectId,
-    });
-
-    const rows = await testDb.$queryRawUnsafe<{ note_id: string }[]>(
-      "SELECT note_id FROM notes_fts WHERE note_id = ?",
-      note.id
-    );
-    expect(rows.length).toBe(1);
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-    await testDb.projectNote.delete({ where: { id: note.id } });
-  });
-
-  it("throws ZodError for empty title", async () => {
-    await expect(
-      createNote({
-        title: "",
-        content: "Some content",
-        projectId: testProjectId,
-      })
-    ).rejects.toThrow();
-  });
-
-  it("throws ZodError for missing projectId", async () => {
-    await expect(
-      createNote({
-        title: "Valid Title",
-        content: "Some content",
-        projectId: "",
-      })
-    ).rejects.toThrow();
-  });
-});
-
-describe("updateNote", () => {
-  it("updates the title and content of a note", async () => {
-    const note = await createNote({
-      title: "Original Title",
-      content: "Original content",
-      projectId: testProjectId,
-    });
-
-    const updated = await updateNote(note.id, {
-      title: "Updated Title",
-      content: "Updated content",
-    });
-
-    expect(updated.title).toBe("Updated Title");
-    expect(updated.content).toBe("Updated content");
-    expect(updated.id).toBe(note.id);
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-    await testDb.projectNote.delete({ where: { id: note.id } });
-  });
-
-  it("re-syncs FTS after update", async () => {
-    const note = await createNote({
-      title: "Before Update",
-      content: "Old content",
-      projectId: testProjectId,
-    });
-
-    await updateNote(note.id, { title: "After Update", content: "New content" });
-
-    const rows = await testDb.$queryRawUnsafe<{ title: string }[]>(
-      "SELECT title FROM notes_fts WHERE note_id = ?",
-      note.id
-    );
-    expect(rows.length).toBe(1);
-    expect(rows[0].title).toBe("After Update");
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-    await testDb.projectNote.delete({ where: { id: note.id } });
-  });
-
-  it("throws ZodError for title that is empty string", async () => {
-    const note = await createNote({
-      title: "Valid Note",
-      content: "Valid content",
-      projectId: testProjectId,
-    });
-
-    await expect(updateNote(note.id, { title: "" })).rejects.toThrow();
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-    await testDb.projectNote.delete({ where: { id: note.id } });
-  });
-});
-
-describe("deleteNote", () => {
-  it("deletes the note and removes from FTS", async () => {
-    const note = await createNote({
-      title: "To Delete",
-      content: "Delete me",
-      projectId: testProjectId,
-    });
-
-    await deleteNote(note.id);
-
-    const found = await testDb.projectNote.findUnique({ where: { id: note.id } });
-    expect(found).toBeNull();
-
-    const ftsRows = await testDb.$queryRawUnsafe<{ note_id: string }[]>(
-      "SELECT note_id FROM notes_fts WHERE note_id = ?",
-      note.id
-    );
-    expect(ftsRows.length).toBe(0);
-  });
-});
-
-describe("getNoteById", () => {
-  it("returns the note when found", async () => {
-    const note = await createNote({
-      title: "Get By ID",
-      content: "Found it",
-      projectId: testProjectId,
-    });
-
-    const found = await getNoteById(note.id);
-    expect(found).not.toBeNull();
-    expect(found!.id).toBe(note.id);
-
-    // Cleanup
-    await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", note.id);
-    await testDb.projectNote.delete({ where: { id: note.id } });
-  });
-
-  it("returns null for a non-existent note", async () => {
-    const found = await getNoteById("nonexistent-id-12345");
-    expect(found).toBeNull();
-  });
-});
-
-describe("getProjectNotes", () => {
-  it("returns all notes for a project without category filter", async () => {
-    const note1 = await createNote({
-      title: "Note One",
-      content: "Content 1",
-      category: "账号",
-      projectId: testProjectId,
-    });
-    const note2 = await createNote({
-      title: "Note Two",
-      content: "Content 2",
-      category: "环境",
-      projectId: testProjectId,
-    });
-
-    const notes = await getProjectNotes(testProjectId);
-    const ids = notes.map((n) => n.id);
-    expect(ids).toContain(note1.id);
-    expect(ids).toContain(note2.id);
-
-    // Cleanup
-    for (const n of [note1, note2]) {
-      await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", n.id);
-      await testDb.projectNote.delete({ where: { id: n.id } });
-    }
-  });
-
-  it("filters notes by category when category option is provided", async () => {
-    const accountNote = await createNote({
-      title: "Account Note",
-      content: "Account info",
-      category: "账号",
-      projectId: testProjectId,
-    });
-    const envNote = await createNote({
-      title: "Env Note",
-      content: "Env config",
-      category: "环境",
-      projectId: testProjectId,
-    });
-
-    const accountNotes = await getProjectNotes(testProjectId, { category: "账号" });
-    const ids = accountNotes.map((n) => n.id);
-    expect(ids).toContain(accountNote.id);
-    expect(ids).not.toContain(envNote.id);
-
-    // Cleanup
-    for (const n of [accountNote, envNote]) {
-      await testDb.$executeRawUnsafe("DELETE FROM notes_fts WHERE note_id = ?", n.id);
-      await testDb.projectNote.delete({ where: { id: n.id } });
-    }
-  });
-});

package/.next/standalone/tower/tests/unit/lib/preview-process-manager.test.ts

@@ -1,107 +0,0 @@
-// @vitest-environment node
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// We import the module under test — module-level Map persists within a test file
-import {
-  registerPreviewProcess,
-  killPreviewProcess,
-  isPreviewRunning,
-} from "@/lib/preview-process";
-
-import type { ChildProcess } from "node:child_process";
-
-/** Create a fake ChildProcess with controllable state */
-function makeFakeChild(killed = false): ChildProcess {
-  return {
-    killed,
-    kill: vi.fn(),
-    pid: Math.floor(Math.random() * 10000),
-    on: vi.fn(),
-  } as unknown as ChildProcess;
-}
-
-// Clear any registered processes between tests by killing them all
-beforeEach(() => {
-  // Stop any lingering processes from previous tests
-  // We use a known taskId list approach — just call kill on common IDs
-  killPreviewProcess("task-1");
-  killPreviewProcess("task-2");
-  killPreviewProcess("task-3");
-  killPreviewProcess("task-unknown");
-});
-
-describe("registerPreviewProcess", () => {
-  it("stores the process so isPreviewRunning returns true", () => {
-    const child = makeFakeChild();
-    registerPreviewProcess("task-1", child);
-    expect(isPreviewRunning("task-1")).toBe(true);
-  });
-
-  it("overwrites an existing process for the same taskId", () => {
-    const child1 = makeFakeChild();
-    const child2 = makeFakeChild();
-    registerPreviewProcess("task-1", child1);
-    registerPreviewProcess("task-1", child2);
-    // Still running (child2 is alive)
-    expect(isPreviewRunning("task-1")).toBe(true);
-    // Clean up
-    killPreviewProcess("task-1");
-  });
-});
-
-describe("isPreviewRunning", () => {
-  it("returns false for unknown taskId", () => {
-    expect(isPreviewRunning("task-unknown")).toBe(false);
-  });
-
-  it("returns true when process is registered and not killed", () => {
-    const child = makeFakeChild(false);
-    registerPreviewProcess("task-1", child);
-    expect(isPreviewRunning("task-1")).toBe(true);
-  });
-
-  it("returns false when process has been killed externally", () => {
-    const child = makeFakeChild(true);
-    registerPreviewProcess("task-1", child);
-    expect(isPreviewRunning("task-1")).toBe(false);
-  });
-});
-
-describe("killPreviewProcess", () => {
-  it("returns false for unknown taskId", () => {
-    const result = killPreviewProcess("task-unknown");
-    expect(result).toBe(false);
-  });
-
-  it("calls kill(SIGTERM), removes from map, and returns true for a live process", () => {
-    const child = makeFakeChild(false);
-    registerPreviewProcess("task-1", child);
-
-    const result = killPreviewProcess("task-1");
-
-    expect(result).toBe(true);
-    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
-    // Process removed from map
-    expect(isPreviewRunning("task-1")).toBe(false);
-  });
-
-  it("returns false (not re-killed) when process is already killed", () => {
-    const child = makeFakeChild(true); // already killed
-    registerPreviewProcess("task-2", child);
-
-    const result = killPreviewProcess("task-2");
-
-    // Removed from map, but kill() not called because already killed
-    expect(result).toBe(false);
-    expect(child.kill).not.toHaveBeenCalled();
-  });
-
-  it("after killing, isPreviewRunning returns false", () => {
-    const child = makeFakeChild(false);
-    registerPreviewProcess("task-3", child);
-
-    killPreviewProcess("task-3");
-
-    expect(isPreviewRunning("task-3")).toBe(false);
-  });
-});

package/.next/standalone/tower/tests/unit/lib/process-manager.test.ts

@@ -1,10 +0,0 @@
-// @vitest-environment node
-// This test file is intentionally empty.
-// The adapter process-manager (canStartExecution, runningProcesses) was removed in Phase 29
-// as part of adapter dead-code cleanup. Task execution is now fully handled by the
-// PTY session layer (src/lib/pty-session.ts) with no per-execution concurrency gate.
-import { describe, it } from "vitest";
-
-describe("process-manager (removed)", () => {
-  it.todo("adapter process-manager deleted in Phase 29 — tests no longer applicable");
-});

package/.next/standalone/tower/tests/unit/lib/pty-session.test.ts

@@ -1,171 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-// Mock node-pty to avoid native addon in test environment
-const mockPty = {
-  onData: vi.fn(),
-  onExit: vi.fn(),
-  write: vi.fn(),
-  resize: vi.fn(),
-  kill: vi.fn(),
-};
-
-vi.mock("node-pty", () => ({
-  spawn: vi.fn(() => mockPty),
-}));
-
-import { PtySession } from "@/lib/pty/pty-session";
-
-describe("PtySession", () => {
-  let onData: ReturnType<typeof vi.fn>;
-  let onExit: ReturnType<typeof vi.fn>;
-  let session: PtySession;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    onData = vi.fn();
-    onExit = vi.fn();
-    // Reset mockPty callbacks
-    mockPty.onData.mockImplementation(() => {});
-    mockPty.onExit.mockImplementation(() => {});
-    session = new PtySession("task-1", "bash", [], "/tmp", onData, onExit);
-  });
-
-  afterEach(() => {
-    // Clean up
-  });
-
-  describe("constructor", () => {
-    it("sets taskId", () => {
-      expect(session.taskId).toBe("task-1");
-    });
-
-    it("initializes killed as false", () => {
-      expect(session.killed).toBe(false);
-    });
-
-    it("initializes disconnectTimer as null", () => {
-      expect(session.disconnectTimer).toBeNull();
-    });
-
-    it("registers onData and onExit callbacks on the PTY", () => {
-      expect(mockPty.onData).toHaveBeenCalledOnce();
-      expect(mockPty.onExit).toHaveBeenCalledOnce();
-    });
-  });
-
-  describe("ring buffer", () => {
-    it("accumulates data in buffer", () => {
-      const dataCallback = mockPty.onData.mock.calls[0][0];
-      dataCallback("hello");
-      dataCallback(" world");
-      expect(session.getBuffer()).toBe("hello world");
-    });
-
-    it("calls onData listener for each chunk", () => {
-      const dataCallback = mockPty.onData.mock.calls[0][0];
-      dataCallback("chunk1");
-      dataCallback("chunk2");
-      expect(onData).toHaveBeenCalledTimes(2);
-      expect(onData).toHaveBeenCalledWith("chunk1");
-      expect(onData).toHaveBeenCalledWith("chunk2");
-    });
-
-    it("trims buffer to BUFFER_MAX (50KB)", () => {
-      const dataCallback = mockPty.onData.mock.calls[0][0];
-      // Write 60KB of data
-      const bigChunk = "x".repeat(60 * 1024);
-      dataCallback(bigChunk);
-      const buffer = session.getBuffer();
-      expect(buffer.length).toBe(50 * 1024);
-    });
-  });
-
-  describe("onExit", () => {
-    it("sets killed=true on PTY exit", () => {
-      const exitCallback = mockPty.onExit.mock.calls[0][0];
-      exitCallback({ exitCode: 0, signal: 0 });
-      expect(session.killed).toBe(true);
-    });
-
-    it("calls onExit callback with exitCode", () => {
-      const exitCallback = mockPty.onExit.mock.calls[0][0];
-      exitCallback({ exitCode: 1, signal: 15 });
-      expect(onExit).toHaveBeenCalledWith(1, 15);
-    });
-
-    it("notifies the registered exit listener via setExitListener", () => {
-      const listener1 = vi.fn();
-      const listener2 = vi.fn();
-      session.setExitListener(listener1);
-      session.setExitListener(listener2);
-
-      const exitCallback = mockPty.onExit.mock.calls[0][0];
-      exitCallback({ exitCode: 0, signal: 0 });
-
-      // setExitListener replaces previous listener — only listener2 should fire
-      expect(listener2).toHaveBeenCalledWith(0);
-    });
-  });
-
-  describe("setDataListener", () => {
-    it("replaces the data listener", () => {
-      const newListener = vi.fn();
-      session.setDataListener(newListener);
-
-      const dataCallback = mockPty.onData.mock.calls[0][0];
-      dataCallback("new data");
-
-      expect(newListener).toHaveBeenCalledWith("new data");
-      // Original listener should NOT be called for new data
-      // (it was called during construction if any data arrived then)
-    });
-  });
-
-  describe("write", () => {
-    it("forwards data to PTY when not killed", () => {
-      session.write("hello");
-      expect(mockPty.write).toHaveBeenCalledWith("hello");
-    });
-
-    it("does NOT write to PTY when killed", () => {
-      session.kill();
-      session.write("hello");
-      expect(mockPty.write).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("resize", () => {
-    it("forwards resize to PTY when not killed", () => {
-      session.resize(120, 40);
-      expect(mockPty.resize).toHaveBeenCalledWith(120, 40);
-    });
-
-    it("does NOT resize PTY when killed", () => {
-      session.kill();
-      session.resize(120, 40);
-      expect(mockPty.resize).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("kill (double-kill guard)", () => {
-    it("kills the PTY on first call", () => {
-      session.kill();
-      expect(session.killed).toBe(true);
-      expect(mockPty.kill).toHaveBeenCalledOnce();
-    });
-
-    it("does NOT kill again on second call", () => {
-      session.kill();
-      session.kill();
-      expect(mockPty.kill).toHaveBeenCalledOnce();
-    });
-
-    it("handles PTY already dead (kill throws)", () => {
-      mockPty.kill.mockImplementationOnce(() => {
-        throw new Error("Process already dead");
-      });
-      expect(() => session.kill()).not.toThrow();
-      expect(session.killed).toBe(true);
-    });
-  });
-});