Files
zitadel/apps/login/src/lib/fingerprint.test.ts
T
RamonandGitHub 057fb8dff2 fix(login): prettier setup (#11798)
# Which Problems Are Solved
Invalid formatting in the login codebase due to invalid prettier
configuration

# How the Problems Are Solved
Fxed .prettierignore wildcards for login source files

# Additional Changes
Removed .prettierrc file because there is already a prettier.config.mjs
file

# Additional Context
2026-03-10 13:30:20 +00:00

528 lines
16 KiB
TypeScript

import { v4 as uuidv4 } from "uuid";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import {
getFingerprintId,
getFingerprintIdCookie,
getOrSetFingerprintId,
getUserAgent,
setFingerprintIdCookie,
} from "./fingerprint";
import { create } from "@zitadel/client";
import { cookies, headers } from "next/headers";
import { userAgent } from "next/server";
// Mock dependencies
vi.mock("uuid");
vi.mock("next/headers", () => ({
cookies: vi.fn(),
headers: vi.fn(),
}));
vi.mock("next/server", () => ({
userAgent: vi.fn(),
}));
vi.mock("@zitadel/client", () => ({
create: vi.fn(),
}));
describe("fingerprint", () => {
beforeEach(() => {
vi.clearAllMocks();
});
afterEach(() => {
vi.restoreAllMocks();
});
describe("getFingerprintId", () => {
it("should generate a UUID v4", async () => {
const mockUuid = "550e8400-e29b-41d4-a716-446655440000";
vi.mocked(uuidv4).mockReturnValue(mockUuid as any);
const result = await getFingerprintId();
expect(result).toBe(mockUuid);
expect(uuidv4).toHaveBeenCalledOnce();
});
it("should generate unique IDs on multiple calls", async () => {
const uuid1 = "550e8400-e29b-41d4-a716-446655440000";
const uuid2 = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
vi.mocked(uuidv4)
.mockReturnValueOnce(uuid1 as any)
.mockReturnValueOnce(uuid2 as any);
const result1 = await getFingerprintId();
const result2 = await getFingerprintId();
expect(result1).toBe(uuid1);
expect(result2).toBe(uuid2);
expect(result1).not.toBe(result2);
});
});
describe("setFingerprintIdCookie", () => {
it("should set cookie with correct name and value", async () => {
const mockSet = vi.fn();
const mockCookies = { set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const fingerprintId = "test-fingerprint-id";
await setFingerprintIdCookie(fingerprintId);
expect(mockSet).toHaveBeenCalledWith({
name: "fingerprintId",
value: fingerprintId,
httpOnly: true,
path: "/",
maxAge: 31536000,
});
});
it("should set httpOnly flag to true", async () => {
const mockSet = vi.fn();
const mockCookies = { set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
await setFingerprintIdCookie("test-id");
const callArgs = mockSet.mock.calls[0][0];
expect(callArgs.httpOnly).toBe(true);
});
it("should set cookie path to root", async () => {
const mockSet = vi.fn();
const mockCookies = { set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
await setFingerprintIdCookie("test-id");
const callArgs = mockSet.mock.calls[0][0];
expect(callArgs.path).toBe("/");
});
it("should set maxAge to 1 year (31536000 seconds)", async () => {
const mockSet = vi.fn();
const mockCookies = { set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
await setFingerprintIdCookie("test-id");
const callArgs = mockSet.mock.calls[0][0];
expect(callArgs.maxAge).toBe(31536000);
expect(callArgs.maxAge).toBe(365 * 24 * 60 * 60);
});
it("should handle special characters in fingerprint ID", async () => {
const mockSet = vi.fn();
const mockCookies = { set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const specialId = "test-id-with-!@#$%^&*()";
await setFingerprintIdCookie(specialId);
const callArgs = mockSet.mock.calls[0][0];
expect(callArgs.value).toBe(specialId);
});
it("should handle empty fingerprint ID", async () => {
const mockSet = vi.fn();
const mockCookies = { set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
await setFingerprintIdCookie("");
expect(mockSet).toHaveBeenCalledWith(
expect.objectContaining({
value: "",
}),
);
});
it("should handle very long fingerprint IDs", async () => {
const mockSet = vi.fn();
const mockCookies = { set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const longId = "a".repeat(1000);
await setFingerprintIdCookie(longId);
const callArgs = mockSet.mock.calls[0][0];
expect(callArgs.value).toBe(longId);
});
});
describe("getFingerprintIdCookie", () => {
it("should retrieve fingerprint cookie", async () => {
const mockGet = vi.fn().mockReturnValue({
name: "fingerprintId",
value: "test-fingerprint",
});
const mockCookies = { get: mockGet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const result = await getFingerprintIdCookie();
expect(mockGet).toHaveBeenCalledWith("fingerprintId");
expect(result).toEqual({
name: "fingerprintId",
value: "test-fingerprint",
});
});
it("should return undefined if cookie doesn't exist", async () => {
const mockGet = vi.fn().mockReturnValue(undefined);
const mockCookies = { get: mockGet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const result = await getFingerprintIdCookie();
expect(result).toBeUndefined();
});
it("should handle null cookie value", async () => {
const mockGet = vi.fn().mockReturnValue(null);
const mockCookies = { get: mockGet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const result = await getFingerprintIdCookie();
expect(result).toBeNull();
});
});
describe("getOrSetFingerprintId", () => {
it("should return existing cookie value if present", async () => {
const existingId = "existing-fingerprint-id";
const mockGet = vi.fn().mockReturnValue({
name: "fingerprintId",
value: existingId,
});
const mockCookies = { get: mockGet, set: vi.fn() };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const result = await getOrSetFingerprintId();
expect(result).toBe(existingId);
expect(mockCookies.set).not.toHaveBeenCalled();
});
it("should generate and set new ID if cookie doesn't exist", async () => {
const newUuid = "new-generated-uuid";
const mockGet = vi.fn().mockReturnValue(undefined);
const mockSet = vi.fn();
const mockCookies = { get: mockGet, set: mockSet };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
vi.mocked(uuidv4).mockReturnValue(newUuid as any);
const result = await getOrSetFingerprintId();
expect(result).toBe(newUuid);
expect(mockSet).toHaveBeenCalledWith({
name: "fingerprintId",
value: newUuid,
httpOnly: true,
path: "/",
maxAge: 31536000,
});
});
it("should not regenerate ID on subsequent calls with existing cookie", async () => {
const existingId = "persistent-id";
const mockGet = vi.fn().mockReturnValue({
name: "fingerprintId",
value: existingId,
});
const mockCookies = { get: mockGet, set: vi.fn() };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const result1 = await getOrSetFingerprintId();
const result2 = await getOrSetFingerprintId();
expect(result1).toBe(existingId);
expect(result2).toBe(existingId);
expect(uuidv4).not.toHaveBeenCalled();
});
});
describe("getUserAgent", () => {
it("should create user agent with all components", async () => {
const mockFingerprintId = "test-fingerprint";
const mockGet = vi.fn().mockReturnValue({
name: "fingerprintId",
value: mockFingerprintId,
});
const mockCookies = { get: mockGet, set: vi.fn() };
vi.mocked(cookies).mockResolvedValue(mockCookies as any);
const mockHeaders = new Map([
["user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"],
["x-forwarded-for", "192.168.1.1"],
]);
vi.mocked(headers).mockResolvedValue({
get: (key: string) => mockHeaders.get(key) ?? null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: { type: "desktop", vendor: "Dell", model: "XPS" },
engine: { name: "Blink", version: "120.0" },
os: { name: "Windows", version: "10" },
browser: { name: "Chrome", version: "120.0" },
} as any);
const mockUserAgent = {
ip: "192.168.1.1",
header: {
"user-agent": {
values: ["Mozilla/5.0 (Windows NT 10.0; Win64; x64)"],
},
},
description: "Chrome, 120.0, desktop, Dell, XPS, , Blink, 120.0, , Windows, 10, ",
fingerprintId: mockFingerprintId,
};
vi.mocked(create).mockReturnValue(mockUserAgent as any);
const result = await getUserAgent();
expect(result).toEqual(mockUserAgent);
expect(create).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
fingerprintId: mockFingerprintId,
ip: "192.168.1.1",
}),
);
});
it("should use x-forwarded-for header for IP if available", async () => {
const mockGet = vi.fn().mockReturnValue({
value: "test-id",
});
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: vi.fn() } as any);
const mockHeaders = new Map([
["x-forwarded-for", "203.0.113.1"],
["remoteAddress", "192.168.1.1"],
]);
vi.mocked(headers).mockResolvedValue({
get: (key: string) => mockHeaders.get(key) ?? null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: {},
engine: {},
os: {},
browser: {},
} as any);
await getUserAgent();
expect(create).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
ip: "203.0.113.1",
}),
);
});
it("should fallback to remoteAddress if x-forwarded-for is not available", async () => {
const mockGet = vi.fn().mockReturnValue({
value: "test-id",
});
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: vi.fn() } as any);
const mockHeaders = new Map([["remoteAddress", "192.168.1.100"]]);
vi.mocked(headers).mockResolvedValue({
get: (key: string) => mockHeaders.get(key) ?? null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: {},
engine: {},
os: {},
browser: {},
} as any);
await getUserAgent();
expect(create).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
ip: "192.168.1.100",
}),
);
});
it("should use empty string for IP if no headers available", async () => {
const mockGet = vi.fn().mockReturnValue({
value: "test-id",
});
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: vi.fn() } as any);
const mockHeaders = new Map();
vi.mocked(headers).mockResolvedValue({
get: (key: string) => mockHeaders.get(key) ?? null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: {},
engine: {},
os: {},
browser: {},
} as any);
await getUserAgent();
expect(create).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
ip: "",
}),
);
});
it("should parse user agent header values", async () => {
const mockGet = vi.fn().mockReturnValue({
value: "test-id",
});
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: vi.fn() } as any);
const userAgentString = "Mozilla/5.0,AppleWebKit/537.36,Chrome/120.0";
const mockHeaders = new Map([["user-agent", userAgentString]]);
vi.mocked(headers).mockResolvedValue({
get: (key: string) => mockHeaders.get(key) ?? null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: {},
engine: {},
os: {},
browser: {},
} as any);
await getUserAgent();
expect(create).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
header: {
"user-agent": {
values: ["Mozilla/5.0", "AppleWebKit/537.36", "Chrome/120.0"],
},
},
}),
);
});
it("should build description from device components", async () => {
const mockGet = vi.fn().mockReturnValue({
value: "test-id",
});
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: vi.fn() } as any);
vi.mocked(headers).mockResolvedValue({
get: () => null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: { type: "mobile", vendor: "Apple", model: "iPhone 15" },
engine: { name: "WebKit", version: "605.1.15" },
os: { name: "iOS", version: "17.0" },
browser: { name: "Safari", version: "17.0" },
} as any);
await getUserAgent();
const createCall = vi.mocked(create).mock.calls[0]?.[1];
expect(createCall).toBeDefined();
expect(createCall?.description).toContain("Safari");
expect(createCall?.description).toContain("17.0");
expect(createCall?.description).toContain("mobile");
expect(createCall?.description).toContain("Apple");
expect(createCall?.description).toContain("iPhone 15");
expect(createCall?.description).toContain("WebKit");
expect(createCall?.description).toContain("iOS");
});
it("should handle missing device components gracefully", async () => {
const mockGet = vi.fn().mockReturnValue({
value: "test-id",
});
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: vi.fn() } as any);
vi.mocked(headers).mockResolvedValue({
get: () => null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: {},
engine: {},
os: {},
browser: {},
} as any);
await getUserAgent();
expect(create).toHaveBeenCalled();
const createCall = vi.mocked(create).mock.calls[0]?.[1];
expect(createCall?.description).toBeDefined();
});
it("should handle partial device information", async () => {
const mockGet = vi.fn().mockReturnValue({
value: "test-id",
});
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: vi.fn() } as any);
vi.mocked(headers).mockResolvedValue({
get: () => null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: { vendor: "Samsung" },
engine: { name: "Blink" },
os: { name: "Android" },
browser: { name: "Chrome" },
} as any);
await getUserAgent();
const createCall = vi.mocked(create).mock.calls[0]?.[1];
expect(createCall).toBeDefined();
expect(createCall?.description).toContain("Samsung");
expect(createCall?.description).toContain("Blink");
expect(createCall?.description).toContain("Android");
expect(createCall?.description).toContain("Chrome");
});
it("should generate new fingerprint ID if none exists", async () => {
const newUuid = "newly-generated-fingerprint";
const mockGet = vi.fn().mockReturnValue(undefined);
const mockSet = vi.fn();
vi.mocked(cookies).mockResolvedValue({ get: mockGet, set: mockSet } as any);
vi.mocked(uuidv4).mockReturnValue(newUuid as any);
vi.mocked(headers).mockResolvedValue({
get: () => null,
} as any);
vi.mocked(userAgent).mockReturnValue({
device: {},
engine: {},
os: {},
browser: {},
} as any);
await getUserAgent();
expect(create).toHaveBeenCalledWith(
expect.anything(),
expect.objectContaining({
fingerprintId: newUuid,
}),
);
});
});
});