mi
224 lines
8.1 KiB
TypeScript
224 lines
8.1 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
||
|
||
const secureValues = vi.hoisted(() => new Map<string, string>());
|
||
|
||
vi.mock("expo-constants", () => ({
|
||
default: { expoConfig: { version: "1.0.0" } },
|
||
}));
|
||
vi.mock("expo-crypto", () => ({
|
||
CryptoDigestAlgorithm: { SHA256: "SHA-256" },
|
||
randomUUID: vi.fn(() => "123e4567-e89b-42d3-a456-426614174000"),
|
||
digestStringAsync: vi.fn(async () => "stable-fingerprint"),
|
||
}));
|
||
vi.mock("expo-auth-session", () => ({
|
||
makeRedirectUri: vi.fn(() => "https://example.test/auth/callback"),
|
||
}));
|
||
vi.mock("expo-secure-store", () => ({
|
||
getItemAsync: vi.fn(async (key: string) => secureValues.get(key) ?? null),
|
||
setItemAsync: vi.fn(async (key: string, value: string) => { secureValues.set(key, value); }),
|
||
deleteItemAsync: vi.fn(async (key: string) => { secureValues.delete(key); }),
|
||
}));
|
||
vi.mock("expo-web-browser", () => ({
|
||
maybeCompleteAuthSession: vi.fn(),
|
||
openAuthSessionAsync: vi.fn(),
|
||
openBrowserAsync: vi.fn(),
|
||
}));
|
||
vi.mock("expo-document-picker", () => ({
|
||
getDocumentAsync: vi.fn(),
|
||
}));
|
||
vi.mock("expo-file-system", () => ({
|
||
File: vi.fn(),
|
||
Paths: { cache: "file:///cache" },
|
||
}));
|
||
vi.mock("expo-file-system/legacy", () => ({
|
||
FileSystemUploadType: { BINARY_CONTENT: 0 },
|
||
createUploadTask: vi.fn(),
|
||
downloadAsync: vi.fn(),
|
||
}));
|
||
vi.mock("expo-linking", () => ({
|
||
openURL: vi.fn(),
|
||
addEventListener: vi.fn(() => ({ remove: vi.fn() })),
|
||
}));
|
||
vi.mock("expo-sharing", () => ({
|
||
isAvailableAsync: vi.fn(),
|
||
shareAsync: vi.fn(),
|
||
}));
|
||
vi.mock("react-native", () => ({
|
||
Platform: { OS: "android", Version: "test", constants: {} },
|
||
AppState: { currentState: "active", addEventListener: vi.fn(() => ({ remove: vi.fn() })) },
|
||
}));
|
||
|
||
import { buildOidcDeviceMetadata } from "../../src/oidc-device";
|
||
import { ApiError, isMessageBlockedError } from "../../src/api";
|
||
import { messageFitsLimit, normalizeMessageText } from "../../src/message-text";
|
||
import { reconcileMessages } from "../../src/reconcile";
|
||
import { sessionMemory } from "../../src/session";
|
||
import { SingleFlight } from "../../src/single-flight";
|
||
import { websocketJwtProtocol } from "../../src/realtime";
|
||
import { toNativeFile } from "../../src/native-files";
|
||
import {
|
||
clearPendingTextIntent,
|
||
bindPendingFileIntent,
|
||
bindPendingTextIntent,
|
||
clearPendingFileIntent,
|
||
createPendingTextIntent,
|
||
loadPendingFileIntent,
|
||
loadPendingTextIntent,
|
||
restorePendingIntents,
|
||
savePendingFileIntent,
|
||
savePendingTextIntent,
|
||
} from "../../src/pending-intent";
|
||
import type { Message } from "../../src/types";
|
||
|
||
const message = (id: string, createdAt: string, status: Message["delivery_status"] = "accepted"): Message => ({
|
||
message_id: id,
|
||
dialog_id: "dialog",
|
||
sender_type: "client",
|
||
content_kind: "text",
|
||
text: "Тест",
|
||
attachments: [],
|
||
safety_status: "allowed",
|
||
delivery_status: status,
|
||
created_at: createdAt,
|
||
});
|
||
|
||
describe("reconcileMessages", () => {
|
||
it("устраняет дубли, обновляет статус и сортирует сообщения", () => {
|
||
const result = reconcileMessages(
|
||
[message("2", "2026-01-02T00:00:00Z"), message("1", "2026-01-01T00:00:00Z")],
|
||
[message("2", "2026-01-02T00:00:00Z", "delivered"), message("3", "2026-01-03T00:00:00Z")],
|
||
);
|
||
expect(result.map((item) => item.message_id)).toEqual(["1", "2", "3"]);
|
||
expect(result[1]?.delivery_status).toBe("delivered");
|
||
});
|
||
|
||
it("сортирует realtime-сообщения по абсолютному времени при разных часовых поясах", () => {
|
||
const result = reconcileMessages(
|
||
[message("client", "2026-07-21T15:48:00+03:00")],
|
||
[message("company", "2026-07-21T12:49:00Z")],
|
||
);
|
||
|
||
expect(result.map((item) => item.message_id)).toEqual(["client", "company"]);
|
||
});
|
||
});
|
||
|
||
describe("UX session memory", () => {
|
||
it("хранит идентификатор только в памяти и очищает его", () => {
|
||
sessionMemory.set("ux-test");
|
||
expect(sessionMemory.id).toBe("ux-test");
|
||
sessionMemory.clear();
|
||
expect(sessionMemory.id).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe("pending message intent", () => {
|
||
it("сохраняет ключи повтора и очищается после завершения", async () => {
|
||
const intent = createPendingTextIntent("Сообщение после входа");
|
||
await savePendingTextIntent(intent);
|
||
|
||
expect(loadPendingTextIntent()).toEqual(intent);
|
||
|
||
await clearPendingTextIntent();
|
||
expect(loadPendingTextIntent()).toBeNull();
|
||
});
|
||
|
||
it("игнорирует повреждённое значение", async () => {
|
||
await clearPendingTextIntent();
|
||
secureValues.set("han.pending-message", "{\"text\":42}");
|
||
await restorePendingIntents();
|
||
expect(loadPendingTextIntent()).toBeNull();
|
||
await clearPendingTextIntent();
|
||
});
|
||
|
||
it("привязывает отложенный текст и файл к созданному диалогу", async () => {
|
||
const textIntent = createPendingTextIntent("После входа");
|
||
await bindPendingTextIntent(textIntent, "dialog-1");
|
||
const file = { uri: "file:///cache/test.txt", name: "test.txt", mimeType: "text/plain", size: 4 };
|
||
await savePendingFileIntent({ file, dialogKey: "file-dialog-key", messageKey: "file-key" });
|
||
await bindPendingFileIntent("dialog-1");
|
||
|
||
expect(loadPendingTextIntent()?.dialogId).toBe("dialog-1");
|
||
expect(loadPendingFileIntent("dialog-1")?.file).toBe(file);
|
||
|
||
await clearPendingTextIntent();
|
||
await clearPendingFileIntent();
|
||
});
|
||
});
|
||
|
||
describe("native file descriptor", () => {
|
||
it("нормализует поля DocumentPicker и подставляет безопасные значения", () => {
|
||
expect(toNativeFile({
|
||
uri: "file:///cache/document",
|
||
name: "document",
|
||
mimeType: null,
|
||
size: null,
|
||
})).toEqual({
|
||
uri: "file:///cache/document",
|
||
name: "document",
|
||
mimeType: "application/octet-stream",
|
||
size: 0,
|
||
});
|
||
});
|
||
});
|
||
|
||
describe("message UX rules", () => {
|
||
it("нормализует текст и проверяет динамический лимит", () => {
|
||
expect(normalizeMessageText(" Ａ ")).toBe("A");
|
||
expect(messageFitsLimit("1234", 4)).toBe(true);
|
||
expect(messageFitsLimit("12345", 4)).toBe(false);
|
||
});
|
||
|
||
it("отличает блокировку message-safety от технической ошибки", () => {
|
||
expect(isMessageBlockedError(new ApiError(422, "message_blocked", "blocked"))).toBe(true);
|
||
expect(isMessageBlockedError(new ApiError(503, "dependency_unavailable", "failed"))).toBe(false);
|
||
});
|
||
});
|
||
|
||
describe("SingleFlight", () => {
|
||
it("объединяет параллельные refresh операции", async () => {
|
||
const flight = new SingleFlight<number>();
|
||
let calls = 0;
|
||
const operation = async () => {
|
||
calls++;
|
||
await Promise.resolve();
|
||
return 42;
|
||
};
|
||
const [first, second, third] = await Promise.all([
|
||
flight.run(operation), flight.run(operation), flight.run(operation),
|
||
]);
|
||
expect([first, second, third]).toEqual([42, 42, 42]);
|
||
expect(calls).toBe(1);
|
||
});
|
||
});
|
||
|
||
describe("WebSocket authentication protocol", () => {
|
||
it("кодирует JWT как canonical han.jwt.<base64url(jwt)>", () => {
|
||
const protocol = websocketJwtProtocol("header.payload.signature");
|
||
expect(protocol).toBe("han.jwt.aGVhZGVyLnBheWxvYWQuc2lnbmF0dXJl");
|
||
expect(protocol).not.toContain("=");
|
||
});
|
||
});
|
||
|
||
describe("OIDC device metadata", () => {
|
||
it("создаёт стабильный Android UUID и передаёт доступные han_* поля", async () => {
|
||
const values = new Map<string, string>();
|
||
const store = {
|
||
get: async (key: string) => values.get(key) ?? null,
|
||
set: async (key: string, value: string) => {
|
||
values.set(key, value);
|
||
},
|
||
};
|
||
|
||
const first = await buildOidcDeviceMetadata(store);
|
||
const second = await buildOidcDeviceMetadata(store);
|
||
|
||
expect(first.han_device_id).toBe("123e4567-e89b-42d3-a456-426614174000");
|
||
expect(second.han_device_id).toBe(first.han_device_id);
|
||
expect(first).toMatchObject({
|
||
han_fingerprint: "stable-fingerprint",
|
||
han_platform: "android",
|
||
han_app_version: "1.0.0",
|
||
});
|
||
});
|
||
});
|