776 行
23 KiB
TypeScript
776 行
23 KiB
TypeScript
import { describe, expect, it, vi, beforeEach } from "vitest";
|
|
import { appRouter } from "./routers";
|
|
import { COOKIE_NAME } from "../shared/const";
|
|
import type { TrpcContext } from "./_core/context";
|
|
|
|
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,
|
|
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: "/",
|
|
});
|
|
});
|
|
});
|
|
|
|
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);
|
|
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");
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
// ===== 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();
|
|
});
|
|
});
|
|
|
|
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);
|
|
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.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 })
|
|
).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");
|
|
}
|
|
});
|
|
});
|
|
|
|
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, selfScore, notes", async () => {
|
|
const user = createTestUser();
|
|
const { ctx } = createMockContext(user);
|
|
const caller = appRouter.createCaller(ctx);
|
|
|
|
try {
|
|
await caller.tutorial.updateProgress({
|
|
tutorialId: 1,
|
|
watched: 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();
|
|
});
|
|
});
|