1361 行
41 KiB
TypeScript
1361 行
41 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { appRouter } from "./routers";
|
|
import { COOKIE_NAME } from "../shared/const";
|
|
import type { TrpcContext } from "./_core/context";
|
|
import * as db from "./db";
|
|
import * as trainingAutomation from "./trainingAutomation";
|
|
import { ENV } from "./_core/env";
|
|
import { sdk } from "./_core/sdk";
|
|
|
|
type AuthenticatedUser = NonNullable<TrpcContext["user"]>;
|
|
|
|
function createTestUser(overrides?: Partial<AuthenticatedUser>): AuthenticatedUser {
|
|
return {
|
|
id: 1,
|
|
openId: "test-user-001",
|
|
email: "test@example.com",
|
|
name: "TestPlayer",
|
|
loginMethod: "username",
|
|
role: "user",
|
|
skillLevel: "beginner",
|
|
trainingGoals: null,
|
|
ntrpRating: 1.5,
|
|
manualNtrpRating: null,
|
|
manualNtrpCapturedAt: null,
|
|
heightCm: null,
|
|
weightKg: null,
|
|
sprintSpeedScore: null,
|
|
explosivePowerScore: null,
|
|
agilityScore: null,
|
|
enduranceScore: null,
|
|
flexibilityScore: null,
|
|
coreStabilityScore: null,
|
|
shoulderMobilityScore: null,
|
|
hipMobilityScore: null,
|
|
assessmentNotes: null,
|
|
totalSessions: 0,
|
|
totalMinutes: 0,
|
|
totalShots: 0,
|
|
currentStreak: 0,
|
|
longestStreak: 0,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
lastSignedIn: new Date(),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createMockContext(user: AuthenticatedUser | null = null): {
|
|
ctx: TrpcContext;
|
|
clearedCookies: { name: string; options: Record<string, unknown> }[];
|
|
setCookies: { name: string; value: string; options: Record<string, unknown> }[];
|
|
} {
|
|
const clearedCookies: { name: string; options: Record<string, unknown> }[] = [];
|
|
const setCookies: { name: string; value: string; options: Record<string, unknown> }[] = [];
|
|
|
|
return {
|
|
ctx: {
|
|
user,
|
|
req: {
|
|
protocol: "https",
|
|
headers: {},
|
|
} as TrpcContext["req"],
|
|
res: {
|
|
clearCookie: (name: string, options: Record<string, unknown>) => {
|
|
clearedCookies.push({ name, options });
|
|
},
|
|
cookie: (name: string, value: string, options: Record<string, unknown>) => {
|
|
setCookies.push({ name, value, options });
|
|
},
|
|
} as TrpcContext["res"],
|
|
},
|
|
clearedCookies,
|
|
setCookies,
|
|
};
|
|
}
|
|
|
|
// ===== AUTH TESTS =====
|
|
|
|
describe("auth.me", () => {
|
|
it("returns null for unauthenticated users", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const result = await caller.auth.me();
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it("returns user data for authenticated users", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const result = await caller.auth.me();
|
|
expect(result).toBeDefined();
|
|
expect(result?.name).toBe("TestPlayer");
|
|
expect(result?.openId).toBe("test-user-001");
|
|
});
|
|
});
|
|
|
|
describe("auth.logout", () => {
|
|
it("clears the session cookie and reports success", async () => {
|
|
const user = createTestUser();
|
|
const { ctx, clearedCookies } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
const result = await caller.auth.logout();
|
|
|
|
expect(result).toEqual({ success: true });
|
|
expect(clearedCookies).toHaveLength(1);
|
|
expect(clearedCookies[0]?.name).toBe(COOKIE_NAME);
|
|
expect(clearedCookies[0]?.options).toMatchObject({
|
|
maxAge: -1,
|
|
secure: true,
|
|
sameSite: "none",
|
|
httpOnly: true,
|
|
path: "/",
|
|
});
|
|
});
|
|
|
|
it("uses lax non-secure cookies for plain http requests", async () => {
|
|
const user = createTestUser();
|
|
const { ctx, clearedCookies } = createMockContext(user);
|
|
ctx.req = {
|
|
protocol: "http",
|
|
headers: {},
|
|
} as TrpcContext["req"];
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
const result = await caller.auth.logout();
|
|
|
|
expect(result).toEqual({ success: true });
|
|
expect(clearedCookies).toHaveLength(1);
|
|
expect(clearedCookies[0]?.options).toMatchObject({
|
|
maxAge: -1,
|
|
secure: false,
|
|
sameSite: "lax",
|
|
httpOnly: true,
|
|
path: "/",
|
|
});
|
|
});
|
|
});
|
|
|
|
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();
|
|
});
|
|
});
|
|
|
|
describe("auth.loginWithUsername invite flow", () => {
|
|
const originalInviteCode = ENV.registrationInviteCode;
|
|
|
|
beforeEach(() => {
|
|
ENV.registrationInviteCode = "CA2026";
|
|
});
|
|
|
|
afterEach(() => {
|
|
ENV.registrationInviteCode = originalInviteCode;
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("allows existing users to log in without an invite code", async () => {
|
|
const existingUser = createTestUser({ name: "ExistingPlayer", openId: "existing-1" });
|
|
const { ctx, setCookies } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
vi.spyOn(db, "getUserByUsername").mockResolvedValueOnce(existingUser);
|
|
const createUsernameAccountSpy = vi.spyOn(db, "createUsernameAccount").mockResolvedValueOnce({
|
|
user: existingUser,
|
|
isNew: false,
|
|
});
|
|
vi.spyOn(sdk, "createSessionToken").mockResolvedValueOnce("session-token");
|
|
|
|
const result = await caller.auth.loginWithUsername({ username: "ExistingPlayer" });
|
|
|
|
expect(result.isNew).toBe(false);
|
|
expect(createUsernameAccountSpy).toHaveBeenCalledWith("ExistingPlayer", undefined);
|
|
expect(setCookies[0]?.name).toBe(COOKIE_NAME);
|
|
});
|
|
|
|
it("rejects new users without the correct invite code", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
vi.spyOn(db, "getUserByUsername").mockResolvedValueOnce(undefined);
|
|
const createUsernameAccountSpy = vi.spyOn(db, "createUsernameAccount");
|
|
|
|
await expect(caller.auth.loginWithUsername({ username: "NewPlayer" })).rejects.toThrow("新用户注册需要正确的邀请码");
|
|
expect(createUsernameAccountSpy).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("allows new users with the correct invite code", async () => {
|
|
const newUser = createTestUser({ name: "NewPlayer", openId: "new-1" });
|
|
const { ctx, setCookies } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
vi.spyOn(db, "getUserByUsername").mockResolvedValueOnce(undefined);
|
|
const createUsernameAccountSpy = vi.spyOn(db, "createUsernameAccount").mockResolvedValueOnce({
|
|
user: newUser,
|
|
isNew: true,
|
|
});
|
|
vi.spyOn(sdk, "createSessionToken").mockResolvedValueOnce("session-token");
|
|
|
|
const result = await caller.auth.loginWithUsername({ username: "NewPlayer", inviteCode: "CA2026" });
|
|
|
|
expect(result.isNew).toBe(true);
|
|
expect(createUsernameAccountSpy).toHaveBeenCalledWith("NewPlayer", "CA2026");
|
|
expect(setCookies[0]?.name).toBe(COOKIE_NAME);
|
|
});
|
|
});
|
|
|
|
// ===== PROFILE TESTS =====
|
|
|
|
describe("profile.stats", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.profile.stats()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
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");
|
|
}
|
|
}
|
|
});
|
|
|
|
it("accepts training assessment fields", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.profile.update({
|
|
heightCm: 178,
|
|
weightKg: 68,
|
|
sprintSpeedScore: 4,
|
|
explosivePowerScore: 3,
|
|
agilityScore: 4,
|
|
enduranceScore: 3,
|
|
flexibilityScore: 3,
|
|
coreStabilityScore: 4,
|
|
shoulderMobilityScore: 3,
|
|
hipMobilityScore: 4,
|
|
manualNtrpRating: 2.5,
|
|
});
|
|
} catch (e: any) {
|
|
expect(e.message).not.toContain("invalid_type");
|
|
}
|
|
});
|
|
});
|
|
|
|
// ===== TRAINING PLAN TESTS =====
|
|
|
|
describe("plan.generate input validation", () => {
|
|
it("rejects invalid skill level", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.plan.generate({ skillLevel: "expert" as any, durationDays: 7 })
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
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 })
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it("rejects duration over 30", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
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();
|
|
});
|
|
|
|
it("rejects generation when training profile is incomplete", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
vi.spyOn(db, "getUserById").mockResolvedValueOnce(user);
|
|
vi.spyOn(db, "getLatestNtrpSnapshot").mockResolvedValueOnce(null as any);
|
|
|
|
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();
|
|
});
|
|
|
|
it("returns null when the user has no active plan", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const getActivePlanSpy = vi.spyOn(db, "getActivePlan").mockResolvedValueOnce(null);
|
|
|
|
await expect(caller.plan.active()).resolves.toBeNull();
|
|
|
|
getActivePlanSpy.mockRestore();
|
|
});
|
|
});
|
|
|
|
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);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.video.upload({
|
|
title: "test",
|
|
format: "mp4",
|
|
fileSize: 1000,
|
|
fileBase64: "dGVzdA==",
|
|
})
|
|
).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.registerExternal input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.video.registerExternal({
|
|
title: "session",
|
|
url: "/media/assets/sessions/demo/recording.webm",
|
|
fileKey: "media/sessions/demo/recording.webm",
|
|
format: "webm",
|
|
})
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it("rejects missing url", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.video.registerExternal({
|
|
title: "session",
|
|
url: "",
|
|
fileKey: "media/sessions/demo/recording.webm",
|
|
format: "webm",
|
|
})
|
|
).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();
|
|
});
|
|
});
|
|
|
|
describe("video.get", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("returns the current user's video", async () => {
|
|
const user = createTestUser({ id: 42 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const createdAt = new Date("2026-03-15T06:00:00.000Z");
|
|
|
|
vi.spyOn(db, "getUserVideoById").mockResolvedValueOnce({
|
|
id: 9,
|
|
userId: 42,
|
|
title: "Forehand Session",
|
|
fileKey: "videos/42/forehand.mp4",
|
|
url: "https://cdn.example.com/videos/42/forehand.mp4",
|
|
format: "mp4",
|
|
fileSize: 1024,
|
|
duration: 12,
|
|
exerciseType: "forehand",
|
|
analysisStatus: "completed",
|
|
createdAt,
|
|
updatedAt: createdAt,
|
|
} as any);
|
|
|
|
const result = await caller.video.get({ videoId: 9 });
|
|
|
|
expect(result.title).toBe("Forehand Session");
|
|
expect(db.getUserVideoById).toHaveBeenCalledWith(42, 9);
|
|
});
|
|
|
|
it("throws not found for videos outside the current user scope", async () => {
|
|
const user = createTestUser({ id: 42 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
vi.spyOn(db, "getUserVideoById").mockResolvedValueOnce(undefined);
|
|
|
|
await expect(caller.video.get({ videoId: 999 })).rejects.toThrow("视频不存在");
|
|
});
|
|
});
|
|
|
|
describe("video.update input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.video.update({ videoId: 1, title: "updated title" })
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it("rejects empty title", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.video.update({ videoId: 1, title: "" })
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("video.update", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("updates the current user's video metadata", async () => {
|
|
const user = createTestUser({ id: 7 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
const updateSpy = vi.spyOn(db, "updateUserVideo").mockResolvedValueOnce(true);
|
|
|
|
const result = await caller.video.update({
|
|
videoId: 14,
|
|
title: "Updated Backhand Session",
|
|
exerciseType: "backhand",
|
|
});
|
|
|
|
expect(result).toEqual({ success: true });
|
|
expect(updateSpy).toHaveBeenCalledWith(7, 14, {
|
|
title: "Updated Backhand Session",
|
|
exerciseType: "backhand",
|
|
});
|
|
});
|
|
|
|
it("throws not found when the video cannot be updated by the current user", async () => {
|
|
const user = createTestUser({ id: 7 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
vi.spyOn(db, "updateUserVideo").mockResolvedValueOnce(false);
|
|
|
|
await expect(
|
|
caller.video.update({
|
|
videoId: 14,
|
|
title: "Updated Backhand Session",
|
|
exerciseType: "backhand",
|
|
})
|
|
).rejects.toThrow("视频不存在");
|
|
});
|
|
});
|
|
|
|
describe("video.delete input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.video.delete({ videoId: 1 })
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("video.delete", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("deletes the current user's video", async () => {
|
|
const user = createTestUser({ id: 11 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
const deleteSpy = vi.spyOn(db, "deleteUserVideo").mockResolvedValueOnce(true);
|
|
|
|
const result = await caller.video.delete({ videoId: 20 });
|
|
|
|
expect(result).toEqual({ success: true });
|
|
expect(deleteSpy).toHaveBeenCalledWith(11, 20);
|
|
});
|
|
|
|
it("throws not found when the current user does not own the video", async () => {
|
|
const user = createTestUser({ id: 11 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
vi.spyOn(db, "deleteUserVideo").mockResolvedValueOnce(false);
|
|
|
|
await expect(caller.video.delete({ videoId: 20 })).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 })
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("analysis.getCorrections input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.analysis.getCorrections({
|
|
poseMetrics: {},
|
|
exerciseType: "forehand",
|
|
detectedIssues: [],
|
|
})
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
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 })
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it("accepts valid exercise name", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.record.create({ exerciseName: "正手挥拍", durationMinutes: 30 });
|
|
} catch (e: any) {
|
|
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);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.rating.history()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("rating.current", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
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);
|
|
});
|
|
});
|
|
|
|
// ===== TUTORIAL TESTS =====
|
|
|
|
describe("tutorial.list", () => {
|
|
it("works without authentication (public)", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
const result = await caller.tutorial.list({});
|
|
expect(Array.isArray(result)).toBe(true);
|
|
} catch (e: any) {
|
|
// DB error expected, but should not be auth error
|
|
expect(e.code).not.toBe("UNAUTHORIZED");
|
|
}
|
|
});
|
|
|
|
it("accepts category filter", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.tutorial.list({ category: "forehand" });
|
|
} catch (e: any) {
|
|
expect(e.message).not.toContain("invalid_type");
|
|
}
|
|
});
|
|
|
|
it("accepts skillLevel filter", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.tutorial.list({ skillLevel: "beginner" });
|
|
} catch (e: any) {
|
|
expect(e.message).not.toContain("invalid_type");
|
|
}
|
|
});
|
|
|
|
it("accepts topicArea filter", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.tutorial.list({ topicArea: "tennis_skill" });
|
|
} catch (e: any) {
|
|
expect(e.message).not.toContain("invalid_type");
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("tutorial.progress", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.tutorial.progress()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("tutorial.updateProgress input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(
|
|
caller.tutorial.updateProgress({ tutorialId: 1 })
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it("requires tutorialId", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(
|
|
caller.tutorial.updateProgress({ tutorialId: undefined as any })
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it("accepts optional watched, completed, selfScore, notes", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.tutorial.updateProgress({
|
|
tutorialId: 1,
|
|
watched: 1,
|
|
completed: 1,
|
|
selfScore: 4,
|
|
notes: "Great tutorial",
|
|
});
|
|
} catch (e: any) {
|
|
expect(e.message).not.toContain("invalid_type");
|
|
}
|
|
});
|
|
});
|
|
|
|
// ===== REMINDER TESTS =====
|
|
|
|
describe("reminder.list", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.reminder.list()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("reminder.create input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(
|
|
caller.reminder.create({
|
|
reminderType: "training",
|
|
title: "Test",
|
|
timeOfDay: "08:00",
|
|
daysOfWeek: [1, 2, 3],
|
|
})
|
|
).rejects.toThrow();
|
|
});
|
|
|
|
it("accepts empty title (no min validation on server)", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.reminder.create({
|
|
reminderType: "training",
|
|
title: "",
|
|
timeOfDay: "08:00",
|
|
daysOfWeek: [1],
|
|
});
|
|
} catch (e: any) {
|
|
// DB error expected, but input validation should pass
|
|
expect(e.message).not.toContain("invalid_type");
|
|
}
|
|
});
|
|
|
|
it("accepts any string as reminderType (no enum validation on server)", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.reminder.create({
|
|
reminderType: "custom_type",
|
|
title: "Test",
|
|
timeOfDay: "08:00",
|
|
daysOfWeek: [1],
|
|
});
|
|
} catch (e: any) {
|
|
expect(e.message).not.toContain("invalid_type");
|
|
}
|
|
});
|
|
|
|
it("accepts valid reminder creation", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.reminder.create({
|
|
reminderType: "training",
|
|
title: "Morning Training",
|
|
message: "Time to practice!",
|
|
timeOfDay: "08:00",
|
|
daysOfWeek: [1, 2, 3, 4, 5],
|
|
});
|
|
} catch (e: any) {
|
|
expect(e.message).not.toContain("invalid_type");
|
|
expect(e.message).not.toContain("invalid_enum_value");
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("reminder.toggle input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(
|
|
caller.reminder.toggle({ reminderId: 1, isActive: 1 })
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("reminder.delete input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(
|
|
caller.reminder.delete({ reminderId: 1 })
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
// ===== NOTIFICATION TESTS =====
|
|
|
|
describe("notification.list", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.notification.list()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("notification.unreadCount", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.notification.unreadCount()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("notification.markRead input validation", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(
|
|
caller.notification.markRead({ notificationId: 1 })
|
|
).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("notification.markAllRead", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.notification.markAllRead()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
// ===== VISION LIBRARY TESTS =====
|
|
|
|
describe("vision.library", () => {
|
|
it("requires authentication", async () => {
|
|
const { ctx } = createMockContext(null);
|
|
const caller = appRouter.createCaller(ctx);
|
|
await expect(caller.vision.library()).rejects.toThrow();
|
|
});
|
|
|
|
it("returns seeded references for authenticated users", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const seedSpy = vi.spyOn(db, "seedVisionReferenceImages").mockResolvedValueOnce();
|
|
const listSpy = vi.spyOn(db, "listVisionReferenceImages").mockResolvedValueOnce([
|
|
{
|
|
id: 1,
|
|
slug: "ref-1",
|
|
title: "标准图：正手挥拍",
|
|
exerciseType: "forehand",
|
|
imageUrl: "https://example.com/forehand.jpg",
|
|
sourcePageUrl: "https://example.com/source",
|
|
sourceLabel: "Example",
|
|
author: null,
|
|
license: null,
|
|
expectedFocus: ["肩髋转动"],
|
|
tags: ["forehand"],
|
|
notes: null,
|
|
sortOrder: 1,
|
|
isPublished: 1,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
},
|
|
] as any);
|
|
|
|
const result = await caller.vision.library();
|
|
|
|
expect(seedSpy).toHaveBeenCalledTimes(1);
|
|
expect(listSpy).toHaveBeenCalledTimes(1);
|
|
expect(result).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
describe("vision.runs", () => {
|
|
it("limits regular users to their own vision test runs", async () => {
|
|
const user = createTestUser({ id: 7, role: "user" });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const listSpy = vi.spyOn(db, "listVisionTestRuns").mockResolvedValueOnce([]);
|
|
|
|
await caller.vision.runs({ limit: 20 });
|
|
|
|
expect(listSpy).toHaveBeenCalledWith(7, 20);
|
|
});
|
|
|
|
it("allows admin users to view all vision test runs", async () => {
|
|
const admin = createTestUser({ id: 9, role: "admin", name: "H1" });
|
|
const { ctx } = createMockContext(admin);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const listSpy = vi.spyOn(db, "listVisionTestRuns").mockResolvedValueOnce([]);
|
|
|
|
await caller.vision.runs({ limit: 30 });
|
|
|
|
expect(listSpy).toHaveBeenCalledWith(undefined, 30);
|
|
});
|
|
});
|
|
|
|
describe("vision.seedLibrary", () => {
|
|
it("rejects non-admin users", async () => {
|
|
const user = createTestUser({ role: "user" });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(caller.vision.seedLibrary()).rejects.toThrow();
|
|
});
|
|
});
|
|
|
|
describe("achievement.list", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("returns achievement progress for authenticated users", async () => {
|
|
const user = createTestUser({ id: 12 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const listSpy = vi.spyOn(db, "listUserAchievements").mockResolvedValueOnce([
|
|
{
|
|
id: 1,
|
|
key: "training_day_1",
|
|
name: "开练",
|
|
description: "完成首个训练日",
|
|
category: "consistency",
|
|
rarity: "common",
|
|
icon: "🎾",
|
|
metricKey: "training_days",
|
|
targetValue: 1,
|
|
tier: 1,
|
|
isHidden: 0,
|
|
isActive: 1,
|
|
sortOrder: 1,
|
|
createdAt: new Date(),
|
|
updatedAt: new Date(),
|
|
currentValue: 1,
|
|
progressPct: 100,
|
|
unlockedAt: new Date(),
|
|
unlocked: true,
|
|
},
|
|
] as any);
|
|
|
|
const result = await caller.achievement.list();
|
|
|
|
expect(listSpy).toHaveBeenCalledWith(12);
|
|
expect(result).toHaveLength(1);
|
|
expect((result[0] as any).key).toBe("training_day_1");
|
|
});
|
|
});
|
|
|
|
describe("analysis.liveSessionSave", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("persists a live session and syncs training data", async () => {
|
|
const user = createTestUser({ id: 5 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
const createSessionSpy = vi.spyOn(db, "createLiveAnalysisSession").mockResolvedValueOnce(101);
|
|
const createSegmentsSpy = vi.spyOn(db, "createLiveActionSegments").mockResolvedValueOnce();
|
|
const syncSpy = vi.spyOn(trainingAutomation, "syncLiveTrainingData").mockResolvedValueOnce({
|
|
recordId: 88,
|
|
unlocked: ["training_day_1"],
|
|
});
|
|
|
|
const result = await caller.analysis.liveSessionSave({
|
|
title: "实时分析 正手",
|
|
sessionMode: "practice",
|
|
startedAt: Date.now() - 4_000,
|
|
endedAt: Date.now(),
|
|
durationMs: 4_000,
|
|
dominantAction: "forehand",
|
|
overallScore: 84,
|
|
postureScore: 82,
|
|
balanceScore: 78,
|
|
techniqueScore: 86,
|
|
footworkScore: 75,
|
|
consistencyScore: 80,
|
|
totalActionCount: 3,
|
|
effectiveSegments: 2,
|
|
totalSegments: 3,
|
|
unknownSegments: 1,
|
|
feedback: ["节奏稳定"],
|
|
metrics: { sampleCount: 12 },
|
|
segments: [
|
|
{
|
|
actionType: "forehand",
|
|
isUnknown: false,
|
|
startMs: 500,
|
|
endMs: 2_500,
|
|
durationMs: 2_000,
|
|
confidenceAvg: 0.82,
|
|
score: 84,
|
|
peakScore: 90,
|
|
frameCount: 24,
|
|
issueSummary: ["击球点前移"],
|
|
keyFrames: [500, 1500, 2500],
|
|
clipLabel: "正手挥拍 00:00 - 00:02",
|
|
},
|
|
],
|
|
});
|
|
|
|
expect(createSessionSpy).toHaveBeenCalledTimes(1);
|
|
expect(createSegmentsSpy).toHaveBeenCalledTimes(1);
|
|
expect(syncSpy).toHaveBeenCalledWith(expect.objectContaining({
|
|
userId: 5,
|
|
sessionId: 101,
|
|
dominantAction: "forehand",
|
|
sessionMode: "practice",
|
|
}));
|
|
expect(result).toEqual({ sessionId: 101, trainingRecordId: 88 });
|
|
});
|
|
});
|
|
|
|
describe("rating.refreshMine", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("creates an async NTRP refresh task for the current user", async () => {
|
|
const user = createTestUser({ id: 22 });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const createTaskSpy = vi.spyOn(db, "createBackgroundTask").mockResolvedValueOnce();
|
|
|
|
const result = await caller.rating.refreshMine();
|
|
|
|
expect(createTaskSpy).toHaveBeenCalledWith(expect.objectContaining({
|
|
userId: 22,
|
|
type: "ntrp_refresh_user",
|
|
payload: { targetUserId: 22 },
|
|
}));
|
|
expect(result.taskId).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("admin.users", () => {
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("rejects non-admin users", async () => {
|
|
const user = createTestUser({ role: "user" });
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
await expect(caller.admin.users({ limit: 20 })).rejects.toThrow();
|
|
});
|
|
|
|
it("returns user list for admin users", async () => {
|
|
const admin = createTestUser({ id: 1, role: "admin", name: "H1" });
|
|
const { ctx } = createMockContext(admin);
|
|
const caller = appRouter.createCaller(ctx);
|
|
const usersSpy = vi.spyOn(db, "listUsersForAdmin").mockResolvedValueOnce([
|
|
{
|
|
id: 1,
|
|
name: "H1",
|
|
role: "admin",
|
|
ntrpRating: 3.4,
|
|
totalSessions: 10,
|
|
totalMinutes: 320,
|
|
totalShots: 240,
|
|
currentStreak: 6,
|
|
longestStreak: 12,
|
|
createdAt: new Date(),
|
|
lastSignedIn: new Date(),
|
|
},
|
|
] as any);
|
|
|
|
const result = await caller.admin.users({ limit: 20 });
|
|
|
|
expect(usersSpy).toHaveBeenCalledWith(20);
|
|
expect(result).toHaveLength(1);
|
|
expect((result[0] as any).name).toBe("H1");
|
|
});
|
|
});
|