Checkpoint: v2.0完整版本:新增社区排行榜、每日打卡、24种成就徽章、实时摄像头姿势分析、在线录制(稳定压缩流/断线重连/自动剪辑)、移动端全面适配。47个测试通过。包含完整开发文档。

这个提交包含在:
Manus
2026-03-14 08:04:00 -04:00
父节点 36907d1110
当前提交 2c418b482e
修改 22 个文件,包含 4370 行新增41 行删除

查看文件

@@ -18,6 +18,9 @@ function createTestUser(overrides?: Partial<AuthenticatedUser>): AuthenticatedUs
ntrpRating: 1.5,
totalSessions: 0,
totalMinutes: 0,
totalShots: 0,
currentStreak: 0,
longestStreak: 0,
createdAt: new Date(),
updatedAt: new Date(),
lastSignedIn: new Date(),
@@ -54,6 +57,8 @@ function createMockContext(user: AuthenticatedUser | null = null): {
};
}
// ===== AUTH TESTS =====
describe("auth.me", () => {
it("returns null for unauthenticated users", async () => {
const { ctx } = createMockContext(null);
@@ -94,6 +99,22 @@ describe("auth.logout", () => {
});
});
describe("auth.loginWithUsername input validation", () => {
it("rejects empty username", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.auth.loginWithUsername({ username: "" })).rejects.toThrow();
});
it("rejects username over 64 chars", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.auth.loginWithUsername({ username: "a".repeat(65) })).rejects.toThrow();
});
});
// ===== PROFILE TESTS =====
describe("profile.stats", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
@@ -102,6 +123,38 @@ describe("profile.stats", () => {
});
});
describe("profile.update input validation", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.profile.update({ skillLevel: "beginner" })).rejects.toThrow();
});
it("rejects invalid skill level", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
await expect(caller.profile.update({ skillLevel: "expert" as any })).rejects.toThrow();
});
it("accepts valid skill levels", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
for (const level of ["beginner", "intermediate", "advanced"] as const) {
try {
await caller.profile.update({ skillLevel: level });
} catch (e: any) {
// DB errors expected, but input validation should pass
expect(e.message).not.toContain("invalid_enum_value");
}
}
});
});
// ===== TRAINING PLAN TESTS =====
describe("plan.generate input validation", () => {
it("rejects invalid skill level", async () => {
const user = createTestUser();
@@ -109,23 +162,17 @@ describe("plan.generate input validation", () => {
const caller = appRouter.createCaller(ctx);
await expect(
caller.plan.generate({
skillLevel: "expert" as any,
durationDays: 7,
})
caller.plan.generate({ skillLevel: "expert" as any, durationDays: 7 })
).rejects.toThrow();
});
it("rejects invalid duration", async () => {
it("rejects invalid duration (0)", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
await expect(
caller.plan.generate({
skillLevel: "beginner",
durationDays: 0,
})
caller.plan.generate({ skillLevel: "beginner", durationDays: 0 })
).rejects.toThrow();
});
@@ -135,14 +182,45 @@ describe("plan.generate input validation", () => {
const caller = appRouter.createCaller(ctx);
await expect(
caller.plan.generate({
skillLevel: "beginner",
durationDays: 31,
})
caller.plan.generate({ skillLevel: "beginner", durationDays: 31 })
).rejects.toThrow();
});
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(
caller.plan.generate({ skillLevel: "beginner", durationDays: 7 })
).rejects.toThrow();
});
});
describe("plan.list", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.plan.list()).rejects.toThrow();
});
});
describe("plan.active", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.plan.active()).rejects.toThrow();
});
});
describe("plan.adjust input validation", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.plan.adjust({ planId: 1 })).rejects.toThrow();
});
});
// ===== VIDEO TESTS =====
describe("video.upload input validation", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
@@ -157,18 +235,48 @@ describe("video.upload input validation", () => {
})
).rejects.toThrow();
});
it("rejects missing title", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
await expect(
caller.video.upload({
title: undefined as any,
format: "mp4",
fileSize: 1000,
fileBase64: "dGVzdA==",
})
).rejects.toThrow();
});
});
describe("video.list", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.video.list()).rejects.toThrow();
});
});
describe("video.get input validation", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.video.get({ videoId: 1 })).rejects.toThrow();
});
});
// ===== ANALYSIS TESTS =====
describe("analysis.save input validation", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(
caller.analysis.save({
videoId: 1,
overallScore: 75,
})
caller.analysis.save({ videoId: 1, overallScore: 75 })
).rejects.toThrow();
});
});
@@ -188,16 +296,31 @@ describe("analysis.getCorrections input validation", () => {
});
});
describe("analysis.list", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.analysis.list()).rejects.toThrow();
});
});
describe("analysis.getByVideo", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.analysis.getByVideo({ videoId: 1 })).rejects.toThrow();
});
});
// ===== RECORD TESTS =====
describe("record.create input validation", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(
caller.record.create({
exerciseName: "正手挥拍",
durationMinutes: 30,
})
caller.record.create({ exerciseName: "正手挥拍", durationMinutes: 30 })
).rejects.toThrow();
});
@@ -206,20 +329,32 @@ describe("record.create input validation", () => {
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
// This should not throw on input validation (may throw on DB)
// We just verify the input schema accepts a valid name
try {
await caller.record.create({
exerciseName: "正手挥拍",
durationMinutes: 30,
});
await caller.record.create({ exerciseName: "正手挥拍", durationMinutes: 30 });
} catch (e: any) {
// DB errors are expected in test env, but input validation should pass
expect(e.message).not.toContain("invalid_type");
}
});
});
describe("record.complete input validation", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.record.complete({ recordId: 1 })).rejects.toThrow();
});
});
describe("record.list", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.record.list()).rejects.toThrow();
});
});
// ===== RATING TESTS =====
describe("rating.history", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
@@ -235,3 +370,187 @@ describe("rating.current", () => {
await expect(caller.rating.current()).rejects.toThrow();
});
});
// ===== DAILY CHECK-IN TESTS =====
describe("checkin.today", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.checkin.today()).rejects.toThrow();
});
});
describe("checkin.do", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.checkin.do()).rejects.toThrow();
});
it("accepts optional notes and minutesTrained", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
try {
await caller.checkin.do({ notes: "练了正手", minutesTrained: 30 });
} catch (e: any) {
// DB errors expected, input validation should pass
expect(e.message).not.toContain("invalid_type");
}
});
it("accepts empty input", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
try {
await caller.checkin.do();
} catch (e: any) {
expect(e.message).not.toContain("invalid_type");
}
});
});
describe("checkin.history", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.checkin.history()).rejects.toThrow();
});
it("accepts custom limit", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
try {
await caller.checkin.history({ limit: 30 });
} catch (e: any) {
expect(e.message).not.toContain("invalid_type");
}
});
});
// ===== BADGE TESTS =====
describe("badge.list", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.badge.list()).rejects.toThrow();
});
});
describe("badge.check", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.badge.check()).rejects.toThrow();
});
});
describe("badge.definitions", () => {
it("returns badge definitions without authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
const result = await caller.badge.definitions();
expect(Array.isArray(result)).toBe(true);
expect(result.length).toBeGreaterThan(0);
// Check badge structure
const firstBadge = result[0];
expect(firstBadge).toHaveProperty("key");
expect(firstBadge).toHaveProperty("name");
expect(firstBadge).toHaveProperty("description");
expect(firstBadge).toHaveProperty("icon");
expect(firstBadge).toHaveProperty("category");
});
it("contains expected badge categories", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
const result = await caller.badge.definitions();
const categories = [...new Set(result.map((b: any) => b.category))];
expect(categories).toContain("milestone");
expect(categories).toContain("training");
expect(categories).toContain("streak");
expect(categories).toContain("video");
expect(categories).toContain("analysis");
expect(categories).toContain("rating");
});
it("has unique badge keys", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
const result = await caller.badge.definitions();
const keys = result.map((b: any) => b.key);
const uniqueKeys = [...new Set(keys)];
expect(keys.length).toBe(uniqueKeys.length);
});
});
// ===== LEADERBOARD TESTS =====
describe("leaderboard.get", () => {
it("requires authentication", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
await expect(caller.leaderboard.get()).rejects.toThrow();
});
it("accepts sortBy parameter", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
for (const sortBy of ["ntrpRating", "totalMinutes", "totalSessions", "totalShots"] as const) {
try {
await caller.leaderboard.get({ sortBy, limit: 10 });
} catch (e: any) {
expect(e.message).not.toContain("invalid_enum_value");
}
}
});
it("rejects invalid sortBy", async () => {
const user = createTestUser();
const { ctx } = createMockContext(user);
const caller = appRouter.createCaller(ctx);
await expect(
caller.leaderboard.get({ sortBy: "invalidField" as any })
).rejects.toThrow();
});
});
// ===== BADGE DEFINITIONS UNIT TESTS =====
describe("BADGE_DEFINITIONS via badge.definitions endpoint", () => {
it("all badges have required fields", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
const badges = await caller.badge.definitions();
for (const badge of badges) {
expect(typeof badge.key).toBe("string");
expect(badge.key.length).toBeGreaterThan(0);
expect(typeof badge.name).toBe("string");
expect(typeof badge.description).toBe("string");
expect(typeof badge.icon).toBe("string");
expect(typeof badge.category).toBe("string");
}
});
it("has at least 20 badges defined", async () => {
const { ctx } = createMockContext(null);
const caller = appRouter.createCaller(ctx);
const badges = await caller.badge.definitions();
expect(badges.length).toBeGreaterThanOrEqual(20);
});
});