Alfred/tests/server/db/projects.test.ts

import type Database from "bun:sqlite";

import { describe, expect, test } from "bun:test";

import {
  archiveProject,
  createProject,
  deleteProject,
  getProject,
  listProjects,
  restoreProject,
  updateProject,
} from "../../../src/server/db/projects";
import { createMigratedTestDatabase } from "../../helpers";

function withProjectsDb(callback: (db: Database) => void): void {
  const handle = createMigratedTestDatabase("projects-test");
  try {
    callback(handle.db);
    handle.close();
  } finally {
    handle.cleanup();
  }
}

describe("项目数据访问层", () => {
  test("创建项目", () => {
    withProjectsDb((db) => {
      const result = createProject(db, { description: "测试描述", name: "测试项目" });
      expect("error" in result).toBe(false);
      expect((result as { project: unknown }).project).toBeDefined();

      const row = db.query("SELECT name, description, status FROM projects WHERE name = '测试项目'").get() as {
        description: string;
        name: string;
        status: string;
      };
      expect(row.name).toBe("测试项目");
      expect(row.description).toBe("测试描述");
      expect(row.status).toBe("active");
    });
  });

  test("项目名称全局唯一（含归档项目）", () => {
    withProjectsDb((db) => {
      createProject(db, { name: "唯一名称" });
      const result2 = createProject(db, { name: "唯一名称" });
      expect("error" in result2).toBe(true);
      expect((result2 as unknown as { error: string }).error).toContain("已存在");
    });
  });

  test("trim 后名称为空时创建失败", () => {
    withProjectsDb((db) => {
      const result = createProject(db, { name: "   " });
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能为空");
    });
  });

  test("列表查询（分页和关键字）", () => {
    withProjectsDb((db) => {
      createProject(db, { description: "descA", name: "项目A" });
      createProject(db, { description: "descB", name: "项目B" });
      createProject(db, { name: "其他" });

      const result1 = listProjects(db, { page: 1, pageSize: 20 });
      expect(result1.total).toBe(3);
      expect(result1.items.length).toBe(3);

      const result2 = listProjects(db, { keyword: "项目", page: 1, pageSize: 20 });
      expect(result2.total).toBe(2);

      const result3 = listProjects(db, { page: 1, pageSize: 1 });
      expect(result3.total).toBe(3);
      expect(result3.items.length).toBe(1);
    });
  });

  test("获取项目详情", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { description: "详情", name: "详情项目" });
      const id = (created as { project: { id: string } }).project.id;

      const result = getProject(db, id);
      expect("error" in result).toBe(false);
      const projectResult = result as { project: { description: string } };
      expect(projectResult.project.description).toBe("详情");
    });
  });

  test("获取不存在的项目返回 404 错误", () => {
    withProjectsDb((db) => {
      const result = getProject(db, "nonexistent");
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(404);
    });
  });

  test("更新项目名称和描述", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "原名" });
      const id = (created as { project: { id: string } }).project.id;

      const result = updateProject(db, id, { description: "新描述", name: "新名" });
      expect("error" in result).toBe(false);

      const updated = result as { project: { description: string; name: string } };
      expect(updated.project.name).toBe("新名");
      expect(updated.project.description).toBe("新描述");
    });
  });

  test("更新已归档项目失败", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "待归档" });
      const id = (created as { project: { id: string } }).project.id;
      archiveProject(db, id);

      const result = updateProject(db, id, { name: "新名称" });
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
  });

  test("归档项目", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "待归档" });
      const id = (created as { project: { id: string } }).project.id;

      const result = archiveProject(db, id);
      expect("error" in result).toBe(false);

      const archived = (result as { project: { archivedAt: null | string; status: string } }).project;
      expect(archived.status).toBe("archived");
      expect(archived.archivedAt).not.toBeNull();

      const row = db.query("SELECT status, archived_at FROM projects WHERE id = ?").get(id) as {
        archived_at: null | string;
        status: string;
      };
      expect(row.status).toBe("archived");
      expect(row.archived_at).not.toBeNull();
    });
  });

  test("对已归档项目重复归档失败", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "测试" });
      const id = (created as { project: { id: string } }).project.id;
      archiveProject(db, id);
      const result = archiveProject(db, id);
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
  });

  test("恢复已归档项目", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "恢复测试" });
      const id = (created as { project: { id: string } }).project.id;
      archiveProject(db, id);

      const result = restoreProject(db, id);
      expect("error" in result).toBe(false);

      const restored = (result as { project: { archivedAt: null | string; status: string } }).project;
      expect(restored.status).toBe("active");
      expect(restored.archivedAt).toBeNull();
    });
  });

  test("恢复 active 项目失败", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "活跃项目" });
      const id = (created as { project: { id: string } }).project.id;
      const result = restoreProject(db, id);
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
  });

  test("永久删除已归档项目", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "删除测试" });
      const id = (created as { project: { id: string } }).project.id;
      archiveProject(db, id);

      const result = deleteProject(db, id);
      expect("error" in result).toBe(false);

      const after = getProject(db, id);
      expect("error" in after).toBe(true);
    });
  });

  test("删除 active 项目失败", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "活跃项目" });
      const id = (created as { project: { id: string } }).project.id;

      const result = deleteProject(db, id);
      expect("error" in result).toBe(true);
      expect((result as unknown as { status: number }).status).toBe(409);
    });
  });

  test("创建项目名称超过 10 个字符失败", () => {
    withProjectsDb((db) => {
      const result = createProject(db, { name: "这是一个非常非常长的名字" });
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能超过 10 个字符");
    });
  });

  test("创建项目名称刚好 10 个字符成功", () => {
    withProjectsDb((db) => {
      const result = createProject(db, { name: "一二三四五六七八九十" });
      expect("error" in result).toBe(false);
      const project = (result as { project: { name: string } }).project;
      expect(project.name).toBe("一二三四五六七八九十");
    });
  });

  test("更新项目名称超过 10 个字符失败", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "短名" });
      const id = (created as { project: { id: string } }).project.id;

      const result = updateProject(db, id, { name: "这是一个非常非常长的名字" });
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能超过 10 个字符");
    });
  });

  test("更新项目名称 trim 后为空失败", () => {
    withProjectsDb((db) => {
      const created = createProject(db, { name: "原名" });
      const id = (created as { project: { id: string } }).project.id;

      const result = updateProject(db, id, { name: "   " });
      expect("error" in result).toBe(true);
      expect((result as unknown as { error: string }).error).toContain("不能为空");
    });
  });
});