Track HiveGrid Cloud planning reference
This commit is contained in:
1 parent
b3d5ea6764
commit
e341c5938a
5784 files changed
+1104929
-3
No files matched your search
@@ -0,0 +1,544 @@
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
|
||||
|
||||
vi.mock("~/locale/i18next.server", () => ({
|
||||
getTranslations: vi.fn(async () => ({
|
||||
t: (key: string) =>
|
||||
({
|
||||
"shared.invalidForm": "Form not submitted correctly.",
|
||||
"shared.unexpectedError": "Unexpected error",
|
||||
"settings.profile.errors.firstNameRequired": "First name required",
|
||||
"settings.profile.errors.invalidPassword": "Invalid password.",
|
||||
"settings.profile.errors.passwordMinLength": "Passwords must have least 6 characters.",
|
||||
"settings.profile.errors.currentPasswordRequired": "Current password is required.",
|
||||
"settings.profile.errors.cannotDeleteAdmin": "Cannot delete an admin",
|
||||
"settings.profile.passwordUpdated": "Password updated",
|
||||
"settings.profile.mfa.enrollmentStarted": "Authenticator enrollment started",
|
||||
"settings.profile.mfa.enabled": "Authenticator enabled",
|
||||
"settings.profile.mfa.disabled": "Authenticator disabled",
|
||||
"settings.profile.mfa.enterCode": "Enter the 6-digit authenticator code.",
|
||||
"settings.profile.mfa.noPendingEnrollment": "No pending authenticator enrollment found.",
|
||||
"settings.profile.mfa.invalidCode": "Invalid authenticator code.",
|
||||
})[key] ?? key,
|
||||
})),
|
||||
}));
|
||||
vi.mock("~/utils/loaders.middleware", () => ({
|
||||
requireAuth: vi.fn(),
|
||||
}));
|
||||
vi.mock("~/utils/session.server", () => ({
|
||||
getUserInfo: vi.fn(),
|
||||
getUserSession: vi.fn(),
|
||||
storage: { destroySession: vi.fn() },
|
||||
validateCSRFToken: vi.fn(),
|
||||
}));
|
||||
vi.mock("~/utils/services/.server/urlService", () => ({
|
||||
getTenantIdFromUrl: vi.fn(),
|
||||
}));
|
||||
vi.mock("~/utils/db/tenants.db.server", () => ({
|
||||
getTenant: vi.fn(),
|
||||
}));
|
||||
vi.mock("~/utils/db.server", () => ({
|
||||
db: {
|
||||
user: {
|
||||
findUnique: vi.fn(),
|
||||
},
|
||||
},
|
||||
}));
|
||||
vi.mock("~/utils/db/users.db.server", async (importOriginal) => {
|
||||
const actual = await importOriginal<typeof import("~/utils/db/users.db.server")>();
|
||||
return {
|
||||
...actual,
|
||||
activateUserTotpPendingSecret: vi.fn(),
|
||||
disableUserTotp: vi.fn(),
|
||||
getUserTotpPendingEnrollment: vi.fn(),
|
||||
getUserTotpStatus: vi.fn(),
|
||||
setUserMfaRecoveryCodes: vi.fn(),
|
||||
setUserTotpPendingSecret: vi.fn(),
|
||||
updateUserPassword: vi.fn(),
|
||||
updateUserProfile: vi.fn(),
|
||||
};
|
||||
});
|
||||
vi.mock("~/services/auth/totp.server", () => ({
|
||||
startTotpEnrollment: vi.fn(),
|
||||
verifyTotpCode: vi.fn(),
|
||||
}));
|
||||
vi.mock("~/utils/auth/mfa/recovery-codes.server", () => ({
|
||||
generateRecoveryCodes: vi.fn(),
|
||||
}));
|
||||
vi.mock("~/modules/events/services/.server/EventsService", () => ({
|
||||
default: { create: vi.fn() },
|
||||
}));
|
||||
vi.mock("bcryptjs", () => ({
|
||||
default: { compare: vi.fn(), hash: vi.fn() },
|
||||
}));
|
||||
vi.mock("~/utils/auth/passwordHasher.server", () => ({
|
||||
hashPassword: vi.fn(async () => "new-hash"),
|
||||
verifyPassword: vi.fn(async () => ({ valid: true })),
|
||||
}));
|
||||
vi.mock("~/services/auth/password-policy.server", () => ({
|
||||
validatePassword: vi.fn(async () => ({ valid: true, errors: [] })),
|
||||
loadPasswordPolicy: vi.fn(() => ({
|
||||
minLength: 1,
|
||||
requireUpper: false,
|
||||
requireLower: false,
|
||||
requireDigit: false,
|
||||
requireSpecial: false,
|
||||
hibpCheck: false,
|
||||
hibpMaxOccurrences: 0,
|
||||
})),
|
||||
MIN_PASSWORD_LENGTH: 12,
|
||||
}));
|
||||
vi.mock("~/utils/integrations/storageService", () => ({ storeFile: vi.fn() }));
|
||||
vi.mock("~/utils/services/userService", () => ({ deleteUserWithItsTenants: vi.fn() }));
|
||||
|
||||
import { hashPassword, verifyPassword } from "~/utils/auth/passwordHasher.server";
|
||||
import { validatePassword as validatePolicyPassword } from "~/services/auth/password-policy.server";
|
||||
import EventsService from "~/modules/events/services/.server/EventsService";
|
||||
import { generateRecoveryCodes } from "~/utils/auth/mfa/recovery-codes.server";
|
||||
import { startTotpEnrollment, verifyTotpCode } from "~/services/auth/totp.server";
|
||||
import { db } from "~/utils/db.server";
|
||||
import {
|
||||
activateUserTotpPendingSecret,
|
||||
disableUserTotp,
|
||||
getUserTotpPendingEnrollment,
|
||||
getUserTotpStatus,
|
||||
setUserMfaRecoveryCodes,
|
||||
setUserTotpPendingSecret,
|
||||
updateUserPassword,
|
||||
updateUserProfile,
|
||||
} from "~/utils/db/users.db.server";
|
||||
import { getTenant } from "~/utils/db/tenants.db.server";
|
||||
import { requireAuth } from "~/utils/loaders.middleware";
|
||||
import { getUserInfo, getUserSession, storage } from "~/utils/session.server";
|
||||
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
|
||||
import { storeFile } from "~/utils/integrations/storageService";
|
||||
import { deleteUserWithItsTenants } from "~/utils/services/userService";
|
||||
import { action, loader } from "./profile";
|
||||
import { appendCSRFToken } from "~/utils/csrf";
|
||||
|
||||
const params = { tenant: "acme" };
|
||||
const user = {
|
||||
id: "user_1",
|
||||
email: "ada@example.com",
|
||||
passwordHash: "hashed-password",
|
||||
firstName: "Ada",
|
||||
lastName: "Lovelace",
|
||||
admin: null,
|
||||
};
|
||||
const tenant = { id: "tenant_1", slug: "acme" };
|
||||
const disabledStatus = { enabled: false, pending: false, enabledAt: null, pendingCreatedAt: null };
|
||||
const pendingStatus = { enabled: false, pending: true, enabledAt: null, pendingCreatedAt: new Date("2026-05-08T12:00:00.000Z") };
|
||||
const enabledStatus = { enabled: true, pending: false, enabledAt: new Date("2026-05-08T12:05:00.000Z"), pendingCreatedAt: null };
|
||||
const recoveryGeneratedAt = new Date("2026-05-08T12:05:01.000Z");
|
||||
const recoveryCodes = ["ABCD-EFGH-JKLM", "NPQR-STUV-WXYZ"];
|
||||
const recoveryEntries = recoveryCodes.map((code, index) => ({ hash: `hash-${index + 1}`, usedAt: null, createdAt: recoveryGeneratedAt }));
|
||||
|
||||
function postRequest(form: FormData) {
|
||||
return new Request("https://app.example.test/acme/settings/profile", {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/x-www-form-urlencoded" },
|
||||
body: new URLSearchParams(form as unknown as Record<string, string>),
|
||||
});
|
||||
}
|
||||
|
||||
function formWithAction(actionName: string, values: Record<string, string> = {}) {
|
||||
const form = new FormData();
|
||||
appendCSRFToken(form);
|
||||
form.set("action", actionName);
|
||||
Object.entries(values).forEach(([key, value]) => form.set(key, value));
|
||||
return form;
|
||||
}
|
||||
|
||||
async function callAction(form: FormData) {
|
||||
return action({
|
||||
request: postRequest(form),
|
||||
params,
|
||||
context: {},
|
||||
unstable_pattern: "app.$tenant/settings/profile",
|
||||
} as ActionFunctionArgs) as Promise<Response>;
|
||||
}
|
||||
|
||||
async function json(response: Response) {
|
||||
return response.json() as Promise<Record<string, unknown>>;
|
||||
}
|
||||
|
||||
function expectNoSecretLeak(payload: unknown) {
|
||||
const serialized = JSON.stringify(payload);
|
||||
expect(serialized).not.toContain("RAWSECRET");
|
||||
expect(serialized).not.toContain("encrypted-secret");
|
||||
expect(serialized).not.toContain("encrypted-pending");
|
||||
expect(serialized).not.toContain("123456");
|
||||
expect(serialized).not.toContain("password-123");
|
||||
expect(serialized).not.toContain("totpSecretEncrypted");
|
||||
expect(serialized).not.toContain("secret");
|
||||
expect(serialized).not.toContain("ABCD-EFGH-JKLM");
|
||||
expect(serialized).not.toContain("NPQR-STUV-WXYZ");
|
||||
expect(serialized).not.toContain("hash-1");
|
||||
expect(serialized).not.toContain("hash-2");
|
||||
}
|
||||
|
||||
describe("profile MFA route actions", () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
vi.mocked(requireAuth).mockResolvedValue(undefined as never);
|
||||
vi.mocked(getUserInfo).mockResolvedValue({ userId: user.id } as never);
|
||||
vi.mocked(getUserSession).mockResolvedValue({ id: "session_1", get: vi.fn(), set: vi.fn(), unset: vi.fn() } as never);
|
||||
vi.mocked(storage.destroySession).mockResolvedValue("RJ_session=; Max-Age=0; Path=/; HttpOnly" as never);
|
||||
vi.mocked(getTenantIdFromUrl).mockResolvedValue(tenant.id);
|
||||
vi.mocked(getTenant).mockResolvedValue(tenant as never);
|
||||
vi.mocked(db.user.findUnique).mockResolvedValue(user as never);
|
||||
vi.mocked(updateUserProfile).mockResolvedValue({ ...user, avatar: "stored-avatar" } as never);
|
||||
vi.mocked(updateUserPassword).mockResolvedValue({ ...user, passwordHash: "new-hash" } as never);
|
||||
vi.mocked(storeFile).mockResolvedValue("stored-avatar" as never);
|
||||
vi.mocked(deleteUserWithItsTenants).mockResolvedValue({ deletedTenants: [{ id: tenant.id, name: "Acme" }] } as never);
|
||||
vi.mocked(getUserTotpStatus).mockResolvedValue(disabledStatus);
|
||||
vi.mocked(verifyPassword).mockResolvedValue({ valid: true });
|
||||
vi.mocked(startTotpEnrollment).mockReturnValue({
|
||||
secret: "RAWSECRET",
|
||||
encryptedSecret: "encrypted-secret",
|
||||
otpauthUri: "otpauth://totp/ToolCTRL:ada@example.com?secret=RAWSECRET&issuer=ToolCTRL",
|
||||
qrValue: "otpauth://totp/ToolCTRL:ada@example.com?secret=RAWSECRET&issuer=ToolCTRL",
|
||||
});
|
||||
vi.mocked(verifyTotpCode).mockReturnValue(true);
|
||||
vi.mocked(getUserTotpPendingEnrollment).mockResolvedValue({
|
||||
totpPendingSecretEncrypted: "encrypted-pending",
|
||||
totpPendingCreatedAt: pendingStatus.pendingCreatedAt,
|
||||
});
|
||||
vi.mocked(generateRecoveryCodes).mockReturnValue({
|
||||
codes: recoveryCodes,
|
||||
entries: recoveryEntries,
|
||||
generatedAt: recoveryGeneratedAt,
|
||||
});
|
||||
});
|
||||
|
||||
it("loader exposes only non-secret MFA status for the current user", async () => {
|
||||
const response = await loader({
|
||||
request: new Request("https://app.example.test/acme/settings/profile"),
|
||||
params,
|
||||
context: {},
|
||||
unstable_pattern: "app.$tenant/settings/profile",
|
||||
} as LoaderFunctionArgs);
|
||||
|
||||
expect(requireAuth).toHaveBeenCalled();
|
||||
expect(getUserTotpStatus).toHaveBeenCalledWith(user.id);
|
||||
expect(response).toMatchObject({ mfaStatus: disabledStatus });
|
||||
expect(response).not.toHaveProperty("recoveryCodes");
|
||||
expectNoSecretLeak(response);
|
||||
});
|
||||
|
||||
it("starts TOTP enrollment after validating the current password", async () => {
|
||||
vi.mocked(getUserTotpStatus).mockResolvedValueOnce(disabledStatus).mockResolvedValueOnce(pendingStatus);
|
||||
|
||||
const response = await callAction(formWithAction("startTotpEnrollment", { passwordCurrent: "password-123" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(200);
|
||||
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
|
||||
expect(setUserTotpPendingSecret).toHaveBeenCalledWith(user.id, "encrypted-secret");
|
||||
expect(body).toEqual({
|
||||
success: "Authenticator enrollment started",
|
||||
mfaStatus: { ...pendingStatus, pendingCreatedAt: pendingStatus.pendingCreatedAt?.toISOString() },
|
||||
otpauthUri: expect.stringContaining("otpauth://"),
|
||||
});
|
||||
expect(JSON.stringify(body)).not.toContain("encrypted-secret");
|
||||
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
|
||||
});
|
||||
|
||||
it("rejects start enrollment with a bad password without persisting pending state", async () => {
|
||||
vi.mocked(verifyPassword).mockResolvedValue({ valid: false });
|
||||
|
||||
const response = await callAction(formWithAction("startTotpEnrollment", { passwordCurrent: "password-123" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Invalid password." });
|
||||
expect(setUserTotpPendingSecret).not.toHaveBeenCalled();
|
||||
expectNoSecretLeak(body);
|
||||
});
|
||||
|
||||
it("confirms pending TOTP enrollment and returns one-time recovery codes", async () => {
|
||||
vi.mocked(getUserTotpStatus).mockResolvedValueOnce(pendingStatus).mockResolvedValueOnce(enabledStatus);
|
||||
|
||||
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "123456", userId: "attacker" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(200);
|
||||
expect(verifyTotpCode).toHaveBeenCalledWith("encrypted-pending", "123456");
|
||||
expect(activateUserTotpPendingSecret).toHaveBeenCalledWith(user.id, "encrypted-pending");
|
||||
expect(generateRecoveryCodes).toHaveBeenCalledTimes(1);
|
||||
expect(setUserMfaRecoveryCodes).toHaveBeenCalledWith(user.id, recoveryEntries, recoveryGeneratedAt);
|
||||
expect(JSON.stringify(vi.mocked(activateUserTotpPendingSecret).mock.calls)).not.toContain("attacker");
|
||||
expect(body).toEqual({
|
||||
success: "Authenticator enabled",
|
||||
mfaStatus: { ...enabledStatus, enabledAt: enabledStatus.enabledAt?.toISOString() },
|
||||
recoveryCodes,
|
||||
});
|
||||
expect(JSON.stringify(body)).not.toContain("hash-1");
|
||||
expect(JSON.stringify(body)).not.toContain("hash-2");
|
||||
const enabledEvent = vi.mocked(EventsService.create).mock.calls.at(-1)?.[0];
|
||||
expect(enabledEvent?.data).toMatchObject({
|
||||
recoveryCodes: { generatedCount: 2, remainingCount: 2, generatedAt: recoveryGeneratedAt },
|
||||
});
|
||||
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
|
||||
});
|
||||
|
||||
it("rejects invalid or missing TOTP codes before verification", async () => {
|
||||
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "12ab56" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Enter the 6-digit authenticator code." });
|
||||
expect(verifyTotpCode).not.toHaveBeenCalled();
|
||||
expect(generateRecoveryCodes).not.toHaveBeenCalled();
|
||||
expect(setUserMfaRecoveryCodes).not.toHaveBeenCalled();
|
||||
expectNoSecretLeak(body);
|
||||
});
|
||||
|
||||
it("rejects confirmation without a pending secret", async () => {
|
||||
vi.mocked(getUserTotpPendingEnrollment).mockResolvedValue({ totpPendingSecretEncrypted: null, totpPendingCreatedAt: null });
|
||||
|
||||
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "123456" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "No pending authenticator enrollment found." });
|
||||
expect(activateUserTotpPendingSecret).not.toHaveBeenCalled();
|
||||
expectNoSecretLeak(body);
|
||||
});
|
||||
|
||||
it("rejects invalid confirmation codes without activating pending state", async () => {
|
||||
vi.mocked(verifyTotpCode).mockReturnValue(false);
|
||||
|
||||
const response = await callAction(formWithAction("confirmTotpEnrollment", { code: "123456" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Invalid authenticator code." });
|
||||
expect(activateUserTotpPendingSecret).not.toHaveBeenCalled();
|
||||
expect(generateRecoveryCodes).not.toHaveBeenCalled();
|
||||
expect(setUserMfaRecoveryCodes).not.toHaveBeenCalled();
|
||||
expectNoSecretLeak(body);
|
||||
});
|
||||
|
||||
it("disables TOTP only after validating the current password", async () => {
|
||||
vi.mocked(getUserTotpStatus).mockResolvedValueOnce(enabledStatus).mockResolvedValueOnce(disabledStatus);
|
||||
|
||||
const response = await callAction(formWithAction("disableTotpEnrollment", { passwordCurrent: "password-123" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(200);
|
||||
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
|
||||
expect(disableUserTotp).toHaveBeenCalledWith(user.id);
|
||||
expect(body).toEqual({ success: "Authenticator disabled", mfaStatus: disabledStatus });
|
||||
expectNoSecretLeak(body);
|
||||
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
|
||||
});
|
||||
|
||||
it("rejects disabling without a password", async () => {
|
||||
const response = await callAction(formWithAction("disableTotpEnrollment"));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ mfaStatus: disabledStatus, mfaError: "Current password is required." });
|
||||
expect(disableUserTotp).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("propagates unauthenticated rejection before reading or mutating MFA state", async () => {
|
||||
const rejection = new Response(null, { status: 302, headers: { Location: "/login" } });
|
||||
vi.mocked(requireAuth).mockRejectedValueOnce(rejection as never);
|
||||
|
||||
await expect(callAction(formWithAction("startTotpEnrollment", { passwordCurrent: "password-123" }))).rejects.toBe(rejection);
|
||||
expect(getUserInfo).not.toHaveBeenCalled();
|
||||
expect(setUserTotpPendingSecret).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("updates profile fields for the authenticated user and ignores tampered form user IDs", async () => {
|
||||
const response = await callAction(
|
||||
formWithAction("profile", {
|
||||
userId: "attacker",
|
||||
firstName: "Grace",
|
||||
lastName: "Hopper",
|
||||
avatar: "data:image/png;base64,avatar",
|
||||
passwordCurrent: "password-123",
|
||||
})
|
||||
);
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(200);
|
||||
expect(storeFile).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
bucket: "users-icons",
|
||||
content: "data:image/png;base64,avatar",
|
||||
id: user.id,
|
||||
scan: expect.objectContaining({ context: "avatar", filename: `${user.id}.avatar` }),
|
||||
})
|
||||
);
|
||||
expect(updateUserProfile).toHaveBeenCalledWith({ firstName: "Grace", lastName: "Hopper", avatar: "stored-avatar" }, user.id);
|
||||
expect(JSON.stringify(vi.mocked(updateUserProfile).mock.calls)).not.toContain("attacker");
|
||||
expect(body).toEqual({ success: "shared.updated" });
|
||||
expect(vi.mocked(EventsService.create).mock.calls.at(-1)?.[0]).toMatchObject({
|
||||
event: "user.profile.updated",
|
||||
userId: user.id,
|
||||
data: {
|
||||
email: user.email,
|
||||
new: { firstName: "Grace", lastName: "Hopper" },
|
||||
old: { firstName: user.firstName, lastName: user.lastName },
|
||||
userId: user.id,
|
||||
},
|
||||
});
|
||||
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
|
||||
});
|
||||
|
||||
it("rejects invalid profile payloads before updating the authenticated user", async () => {
|
||||
const response = await callAction(formWithAction("profile", { firstName: "A", lastName: "Hopper", userId: "attacker" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ error: "Form not submitted correctly.", fields: { firstName: "First name required" } });
|
||||
expect(updateUserProfile).not.toHaveBeenCalled();
|
||||
expect(EventsService.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("changes password only after comparing the current password and hashes the submitted new password", async () => {
|
||||
// hashPassword mock is already set to return "new-hash" globally.
|
||||
|
||||
const response = await callAction(
|
||||
formWithAction("password", {
|
||||
userId: "attacker",
|
||||
passwordCurrent: "password-123",
|
||||
passwordNew: "new-password",
|
||||
passwordNewConfirm: "new-password",
|
||||
})
|
||||
);
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(200);
|
||||
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
|
||||
expect(hashPassword).toHaveBeenCalledWith("new-password");
|
||||
expect(updateUserPassword).toHaveBeenCalledWith({ passwordHash: "new-hash" }, user.id);
|
||||
expect(JSON.stringify(vi.mocked(updateUserPassword).mock.calls)).not.toContain("attacker");
|
||||
expect(body).toEqual({ passwordSuccess: "Password updated" });
|
||||
expect(vi.mocked(EventsService.create).mock.calls.at(-1)?.[0]).toMatchObject({
|
||||
event: "user.password.updated",
|
||||
userId: user.id,
|
||||
data: { user: { id: user.id, email: user.email } },
|
||||
});
|
||||
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
|
||||
});
|
||||
|
||||
it("rejects bad current passwords before hashing or updating the password", async () => {
|
||||
vi.mocked(verifyPassword).mockResolvedValue({ valid: false });
|
||||
|
||||
const response = await callAction(
|
||||
formWithAction("password", { passwordCurrent: "password-123", passwordNew: "new-password", passwordNewConfirm: "new-password" })
|
||||
);
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ error: "Invalid password." });
|
||||
expect(hashPassword).not.toHaveBeenCalled();
|
||||
expect(updateUserPassword).not.toHaveBeenCalled();
|
||||
expect(EventsService.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects invalid password fields before comparing passwords", async () => {
|
||||
vi.mocked(validatePolicyPassword).mockResolvedValueOnce({
|
||||
valid: false,
|
||||
errors: [{ code: "auth.password.errors.tooShort", args: { minLength: 12 } }],
|
||||
});
|
||||
const response = await callAction(formWithAction("password", { passwordCurrent: "password-123", passwordNew: "short", passwordNewConfirm: "short" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ error: "auth.password.errors.tooShort" });
|
||||
expect(verifyPassword).not.toHaveBeenCalled();
|
||||
expect(updateUserPassword).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("deletes only the authenticated non-admin user and keeps deletion events redacted", async () => {
|
||||
const response = await callAction(formWithAction("deleteAccount", { userId: "attacker", passwordCurrent: "password-123" }));
|
||||
|
||||
expect(response.status).toBe(302);
|
||||
expect(response.headers.get("Location")).toBe("/login");
|
||||
expect(getUserSession).toHaveBeenCalled();
|
||||
expect(storage.destroySession).toHaveBeenCalledWith(expect.objectContaining({ id: "session_1" }));
|
||||
expect(response.headers.get("Set-Cookie")).toContain("Max-Age=0");
|
||||
expect(deleteUserWithItsTenants).toHaveBeenCalledWith(user.id);
|
||||
expect(JSON.stringify(vi.mocked(deleteUserWithItsTenants).mock.calls)).not.toContain("attacker");
|
||||
expect(vi.mocked(EventsService.create).mock.calls).toHaveLength(2);
|
||||
expect(vi.mocked(EventsService.create).mock.calls[0][0]).toMatchObject({
|
||||
event: "account.deleted",
|
||||
userId: null,
|
||||
data: { tenant: { id: tenant.id, name: "Acme" }, user: { id: user.id, email: user.email } },
|
||||
});
|
||||
expect(vi.mocked(EventsService.create).mock.calls[1][0]).toMatchObject({
|
||||
event: "user.profile.deleted",
|
||||
userId: null,
|
||||
data: { id: user.id, email: user.email, firstName: user.firstName, lastName: user.lastName },
|
||||
});
|
||||
expectNoSecretLeak(vi.mocked(EventsService.create).mock.calls);
|
||||
});
|
||||
|
||||
it("rejects account deletion without the current password", async () => {
|
||||
const response = await callAction(formWithAction("deleteAccount"));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ error: "Current password is required." });
|
||||
expect(verifyPassword).not.toHaveBeenCalled();
|
||||
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
|
||||
expect(EventsService.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("rejects account deletion with an invalid current password", async () => {
|
||||
vi.mocked(verifyPassword).mockResolvedValue({ valid: false });
|
||||
|
||||
const response = await callAction(formWithAction("deleteAccount", { passwordCurrent: "password-123" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ error: "Invalid password." });
|
||||
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
|
||||
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
|
||||
expect(EventsService.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("returns an error when the deletion service fails after password validation", async () => {
|
||||
vi.mocked(deleteUserWithItsTenants).mockRejectedValueOnce(new Error("delete failed") as never);
|
||||
const consoleError = vi.spyOn(console, "error").mockImplementation(() => undefined);
|
||||
|
||||
const response = await callAction(formWithAction("deleteAccount", { passwordCurrent: "password-123" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ error: "Unexpected error" });
|
||||
expect(verifyPassword).toHaveBeenCalledWith("password-123", user.passwordHash);
|
||||
expect(EventsService.create).not.toHaveBeenCalled();
|
||||
expect(storage.destroySession).not.toHaveBeenCalled();
|
||||
expect(consoleError).toHaveBeenCalledWith(expect.any(Error));
|
||||
consoleError.mockRestore();
|
||||
});
|
||||
|
||||
it("rejects admin account deletion before deleting user data", async () => {
|
||||
vi.mocked(db.user.findUnique).mockResolvedValueOnce({ ...user, admin: { id: "admin_1" } } as never);
|
||||
|
||||
const response = await callAction(formWithAction("deleteAccount", { userId: "attacker", passwordCurrent: "password-123" }));
|
||||
const body = await json(response);
|
||||
|
||||
expect(response.status).toBe(400);
|
||||
expect(body).toEqual({ error: "Cannot delete an admin" });
|
||||
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
|
||||
expect(EventsService.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("propagates unauthenticated rejection before profile, password, or delete mutations", async () => {
|
||||
const rejection = new Response(null, { status: 302, headers: { Location: "/login" } });
|
||||
vi.mocked(requireAuth).mockRejectedValueOnce(rejection as never);
|
||||
|
||||
await expect(callAction(formWithAction("profile", { firstName: "Grace", lastName: "Hopper" }))).rejects.toBe(rejection);
|
||||
expect(getUserInfo).not.toHaveBeenCalled();
|
||||
expect(updateUserProfile).not.toHaveBeenCalled();
|
||||
expect(updateUserPassword).not.toHaveBeenCalled();
|
||||
expect(deleteUserWithItsTenants).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user