445 lines
11 KiB
TypeScript
445 lines
11 KiB
TypeScript
import type { FC, PropsWithChildren } from "react";
|
|
|
|
import { MantineProvider } from "@mantine/core";
|
|
import { act, renderHook, waitFor } from "@testing-library/react";
|
|
import { http, HttpResponse } from "msw";
|
|
import { MemoryRouter, Route, Routes } from "react-router";
|
|
import { describe, expect, it, vi } from "vitest";
|
|
|
|
import type { Portfolio } from "@/entities/portfolio";
|
|
|
|
import { configureAuthClient } from "@/shared/api";
|
|
import { createQueryWrapper } from "@/test/query";
|
|
import { resource } from "@/test/resource";
|
|
import { server } from "@/test/server";
|
|
|
|
import {
|
|
toAccountPagePositionSections,
|
|
useAccountPageViewModel,
|
|
} from "./AccountPage.vm";
|
|
|
|
const portfolio: Portfolio
|
|
= {
|
|
cashBalances: [{ currency: "USD", value: "1" }],
|
|
isStale: true,
|
|
lastSuccessfulAt: "2026-08-13T10:00:00Z",
|
|
positions: [
|
|
{
|
|
absoluteReturn: { currency: "RUB", value: "10" },
|
|
averagePurchasePrice: null,
|
|
currentValue: { currency: "RUB", value: "100" },
|
|
displayName: "Акция",
|
|
figi: "FIGI-STOCK",
|
|
isin: null,
|
|
logoName: "akciya.png",
|
|
quantity: "2",
|
|
ticker: null,
|
|
type: "STOCK",
|
|
},
|
|
{
|
|
absoluteReturn: { currency: "RUB", value: "-5" },
|
|
averagePurchasePrice: { currency: "RUB", value: "45" },
|
|
currentValue: { currency: "RUB", value: "50" },
|
|
displayName: "Облигация",
|
|
figi: "FIGI-BOND",
|
|
isin: "RU000A0JX0J2",
|
|
logoName: null,
|
|
quantity: "1",
|
|
ticker: null,
|
|
type: "BOND",
|
|
},
|
|
{
|
|
absoluteReturn: null,
|
|
averagePurchasePrice: null,
|
|
currentValue: null,
|
|
displayName: "Фонд",
|
|
figi: "FIGI-FUND",
|
|
isin: null,
|
|
logoName: "fond.png",
|
|
quantity: "3",
|
|
ticker: null,
|
|
type: "FUND",
|
|
},
|
|
],
|
|
structure: { currencies: [], unvaluedCategories: [] },
|
|
totalsByCurrency: [{ currency: "RUB", value: "150" }],
|
|
};
|
|
|
|
function configureTestAuth() {
|
|
configureAuthClient({
|
|
accessToken: () => "test-token",
|
|
clear: vi.fn(),
|
|
refresh: () => Promise.resolve(true),
|
|
});
|
|
}
|
|
|
|
function createWrapper() {
|
|
const { wrapper: QueryWrapper } = createQueryWrapper();
|
|
|
|
const Wrapper: FC<PropsWithChildren> = props => (
|
|
<QueryWrapper>
|
|
<MantineProvider>
|
|
<MemoryRouter initialEntries={["/accounts/account-1"]}>
|
|
<Routes>
|
|
<Route element={props.children} path="/accounts/:accountId" />
|
|
</Routes>
|
|
</MemoryRouter>
|
|
</MantineProvider>
|
|
</QueryWrapper>
|
|
);
|
|
|
|
return Wrapper;
|
|
}
|
|
|
|
function mockLoadedAccountPage() {
|
|
server.use(
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/portfolio", () =>
|
|
HttpResponse.json(resource(portfolio)),
|
|
),
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/operations", () =>
|
|
HttpResponse.json(
|
|
|
|
resource(
|
|
{
|
|
accountId: "account-1",
|
|
hasNext: false,
|
|
items: [
|
|
{
|
|
accruedInterest: null,
|
|
category: "trade",
|
|
commission: null,
|
|
description: "Покупка акции",
|
|
figi: "FIGI-STOCK",
|
|
id: "operation-1",
|
|
instrumentType: "share",
|
|
instrumentUid: null,
|
|
occurredAt: "2026-08-13T10:00:00Z",
|
|
payment: { currency: "RUB", value: "-100" },
|
|
price: null,
|
|
quantity: "1",
|
|
ticker: "STK",
|
|
type: "Buy",
|
|
},
|
|
],
|
|
nextCursor: null,
|
|
observedAt: "2026-08-13T10:00:00Z",
|
|
},
|
|
),
|
|
),
|
|
),
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/events", () =>
|
|
HttpResponse.json(
|
|
resource({
|
|
accountId: "account-1",
|
|
calculatedAt: "2026-08-13T10:00:00Z",
|
|
events: Array.from(
|
|
{ length: 6 },
|
|
|
|
(_, index) =>
|
|
({
|
|
date: `2026-09-${String(index + 1).padStart(2, "0")}`,
|
|
dateKind: "event",
|
|
displayName: `Купон ${index}`,
|
|
figi: `FIGI-EVENT-${index}`,
|
|
instrumentUid: null,
|
|
projectedAmount: { currency: "RUB", value: String(index + 1) },
|
|
ticker: `BND${index}`,
|
|
type: "coupon",
|
|
}),
|
|
),
|
|
}),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
describe("useAccountPageViewModel", () => {
|
|
it("excludes currency instruments only from display, preserving order and share denominators", () => {
|
|
const otherTypes = [
|
|
"OPTION",
|
|
"OTHER",
|
|
"FUTURE",
|
|
"STRUCTURED_NOTE",
|
|
"DIGITAL_FINANCIAL_ASSET",
|
|
"FUND",
|
|
] as const;
|
|
|
|
const snapshot: Portfolio = {
|
|
...portfolio,
|
|
cashBalances: [{ currency: "RUB", value: "1000" }],
|
|
positions: [
|
|
...portfolio.positions,
|
|
{
|
|
...portfolio.positions[0],
|
|
currentValue: { currency: "RUB", value: "50" },
|
|
figi: "FIGI-CURRENCY",
|
|
type: "CURRENCY",
|
|
},
|
|
...otherTypes.map(
|
|
|
|
type =>
|
|
({
|
|
...portfolio.positions[2],
|
|
currentValue:
|
|
type === "OPTION" ? { currency: "RUB", value: "50" } : null,
|
|
figi: `FIGI-${type}-NEXT`,
|
|
type,
|
|
}),
|
|
),
|
|
],
|
|
structure: { currencies: [], unvaluedCategories: [] },
|
|
totalsByCurrency: [{ currency: "RUB", value: "1250" }],
|
|
};
|
|
|
|
const original = structuredClone(snapshot);
|
|
|
|
const sections = toAccountPagePositionSections(snapshot);
|
|
|
|
expect(sections.map(section => section.kind)).toEqual([
|
|
"stocks",
|
|
"bonds",
|
|
"other",
|
|
]);
|
|
expect(sections[2].groups.map(group => group.positions[0].figi)).toEqual([
|
|
"FIGI-FUND",
|
|
...otherTypes.map(type => `FIGI-${type}-NEXT`),
|
|
]);
|
|
expect(sections[0].groups[0].positions[0].shareText).toBe("40 %");
|
|
expect(sections[1].groups[0].positions[0].shareText).toBe("20 %");
|
|
expect(sections[2].groups[1].positions[0].shareText).toBe("20 %");
|
|
expect(snapshot).toEqual(original);
|
|
});
|
|
|
|
it("prepares grouped position sections with derived display data", () => {
|
|
expect(
|
|
toAccountPagePositionSections(portfolio).map(({ groups, kind }) => ({
|
|
kind,
|
|
positions: groups.flatMap(group => group.positions),
|
|
})),
|
|
).toMatchObject([
|
|
{
|
|
kind: "stocks",
|
|
positions: [
|
|
{
|
|
displayName: "Акция",
|
|
logoSrc: "https://invest-brands.cdn-tinkoff.ru/akciyax160.png",
|
|
returnText: "+10 ₽",
|
|
returnTone: "positive",
|
|
shareText: "66,7 %",
|
|
},
|
|
],
|
|
|
|
},
|
|
{
|
|
kind: "bonds",
|
|
positions: [
|
|
{
|
|
displayName: "Облигация",
|
|
logoSrc: null,
|
|
returnText: "-5 ₽",
|
|
returnTone: "negative",
|
|
shareText: "33,3 %",
|
|
},
|
|
],
|
|
},
|
|
{
|
|
kind: "other",
|
|
positions: [
|
|
{
|
|
displayName: "Фонд",
|
|
logoSrc: null,
|
|
returnText: null,
|
|
returnTone: undefined,
|
|
shareText: null,
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
});
|
|
|
|
it("prepares recent operations and events state for presentation views", async () => {
|
|
configureTestAuth();
|
|
mockLoadedAccountPage();
|
|
|
|
const { result } = renderHook(() => useAccountPageViewModel(), {
|
|
wrapper: createWrapper(),
|
|
});
|
|
|
|
await waitFor(() =>
|
|
expect(
|
|
(result.current as { recentEvents?: { state: string } }).recentEvents,
|
|
)?.toMatchObject({ state: "loaded" }),
|
|
);
|
|
|
|
const loaded = result.current as Extract<
|
|
typeof result.current,
|
|
{ state: "loaded" }
|
|
>;
|
|
|
|
expect(loaded.recentOperations).toMatchObject({
|
|
items: [{ description: "Покупка акции", id: "operation-1" }],
|
|
state: "loaded",
|
|
to: "/accounts/account-1/operations",
|
|
});
|
|
expect(loaded.recentEvents).toMatchObject({
|
|
items: [
|
|
{ ticker: "BND0" },
|
|
{ ticker: "BND1" },
|
|
{ ticker: "BND2" },
|
|
{ ticker: "BND3" },
|
|
{ ticker: "BND4" },
|
|
],
|
|
state: "loaded",
|
|
to: "/accounts/account-1/events",
|
|
});
|
|
});
|
|
|
|
it("keeps recent errors isolated in the ViewModel presentation state", async () => {
|
|
configureTestAuth();
|
|
server.use(
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/portfolio", () =>
|
|
HttpResponse.json(resource(portfolio)),
|
|
),
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/operations", () =>
|
|
HttpResponse.json({ code: "TBANK_UNAVAILABLE" }, { status: 503 }),
|
|
),
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/events", () =>
|
|
HttpResponse.json({ code: "MOEX_UNAVAILABLE" }, { status: 503 }),
|
|
),
|
|
);
|
|
|
|
const { result } = renderHook(() => useAccountPageViewModel(), {
|
|
wrapper: createWrapper(),
|
|
});
|
|
|
|
await waitFor(() =>
|
|
expect(result.current).toMatchObject({
|
|
recentEvents: { state: "error" },
|
|
recentOperations: { state: "error" },
|
|
state: "loaded",
|
|
}),
|
|
);
|
|
});
|
|
});
|
|
|
|
it("keeps overview sections independent when their source data is incomplete", async () => {
|
|
configureTestAuth();
|
|
mockLoadedAccountPage();
|
|
server.use(
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/portfolio", () =>
|
|
HttpResponse.json(resource(portfolio, { availability: "partial" })),
|
|
),
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/operations", () =>
|
|
HttpResponse.json(
|
|
|
|
resource(
|
|
{ hasNext: false, items: [], nextCursor: null },
|
|
{ availability: "partial" },
|
|
),
|
|
),
|
|
),
|
|
http.get("*/api/v1/brokerage-accounts/:accountId/events", () =>
|
|
HttpResponse.json(
|
|
resource(
|
|
{ events: [], incomeTotalsByCurrency: [] },
|
|
{ availability: "partial" },
|
|
),
|
|
),
|
|
),
|
|
);
|
|
|
|
const { result } = renderHook(() => useAccountPageViewModel(), {
|
|
wrapper: createWrapper(),
|
|
});
|
|
|
|
await waitFor(() => expect(result.current.state).toBe("loaded"));
|
|
await waitFor(() =>
|
|
expect(result.current).toMatchObject({
|
|
partial: true,
|
|
recentEvents: { items: [], state: "partial" },
|
|
recentOperations: { items: [], state: "partial" },
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("refreshes every overview section through one account descriptor and observational reads", async () => {
|
|
configureTestAuth();
|
|
|
|
const sections: Record<string, unknown>
|
|
= {
|
|
"events": { events: [], incomeTotalsByCurrency: [] },
|
|
"income-summary": { totalsByCurrency: [] },
|
|
"operations": { hasNext: false, items: [], nextCursor: null },
|
|
portfolio,
|
|
};
|
|
|
|
const observed: string[] = [];
|
|
const scopes: unknown[] = [];
|
|
let version = "1";
|
|
server.use(
|
|
...Object.entries(sections).map(([path, data]) =>
|
|
http.get(
|
|
`*/api/v1/brokerage-accounts/:accountId/${path}`,
|
|
({ request }) => {
|
|
if (new URL(request.url).searchParams.get("sync") === "observe")
|
|
observed.push(path);
|
|
|
|
return HttpResponse.json(
|
|
resource(data, { resourceKey: path, stateVersion: version }),
|
|
);
|
|
},
|
|
),
|
|
),
|
|
http.post("*/api/v1/tbank-sync", async ({ request }) => {
|
|
scopes.push(await request.json());
|
|
version = "2";
|
|
|
|
return HttpResponse.json(
|
|
{
|
|
id: "overview",
|
|
now: "2026-09-25T00:00:00Z",
|
|
scope: { accountId: "account-1", screen: "account" },
|
|
},
|
|
{ status: 202 },
|
|
);
|
|
}),
|
|
http.get("*/api/v1/tbank-sync/:id", () =>
|
|
|
|
HttpResponse.json(
|
|
{
|
|
errorCode: null,
|
|
id: "overview",
|
|
now: "2026-09-25T00:00:00Z",
|
|
progress: { completed: 4, discovering: false, total: 4 },
|
|
resources: Object.keys(sections).map(
|
|
resourceKey =>
|
|
resource(null, { resourceKey, stateVersion: version }).meta,
|
|
),
|
|
scope: null,
|
|
state: "succeeded",
|
|
},
|
|
),
|
|
),
|
|
);
|
|
|
|
const { result } = renderHook(() => useAccountPageViewModel(), {
|
|
wrapper: createWrapper(),
|
|
});
|
|
|
|
await waitFor(() =>
|
|
expect(result.current).toMatchObject({
|
|
incomeSummary: { state: "empty" },
|
|
recentEvents: { state: "empty" },
|
|
recentOperations: { state: "empty" },
|
|
state: "loaded",
|
|
}),
|
|
);
|
|
await act(async () => {
|
|
if (result.current.state === "loaded") await result.current.retry();
|
|
});
|
|
await waitFor(() =>
|
|
expect(new Set(observed)).toEqual(new Set(Object.keys(sections))),
|
|
);
|
|
expect(scopes).toEqual([{ accountId: "account-1", screen: "account" }]);
|
|
});
|