fin-tracker/app/test/portfolio_test.dart

import 'package:fintracker_api/fintracker_api.dart';
import 'package:fintracker_app/core/cache/cached.dart';
import 'package:fintracker_app/core/widgets/money_text.dart';
import 'package:fintracker_app/features/portfolio/allocation_tab.dart';
import 'package:fintracker_app/features/portfolio/benchmarks_card.dart';
import 'package:fintracker_app/features/portfolio/data/benchmarks_api.dart';
import 'package:fintracker_app/features/portfolio/holdings_tab.dart';
import 'package:fintracker_app/features/portfolio/labels.dart';
import 'package:fintracker_app/features/portfolio/providers.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';

HoldingOut holding({
  required int id,
  required String ticker,
  String? valueRub,
  String priceStatus = 'ok',
  String? weight,
}) {
  return HoldingOut(
    accruedInterestRub: null,
    assetClass: 'share',
    avgCost: '100',
    board: 'TQBR',
    costCurrency: 'RUB',
    costTotalRub: '10000',
    currency: 'RUB',
    daysHeld: 40,
    firstBuyDate: DateTime(2026, 8, 1),
    incomeRub: '0',
    instrumentId: id,
    ldvEligibleQty: '0',
    marketPrice: priceStatus == 'missing' ? null : '110',
    name: ticker,
    priceCurrency: 'RUB',
    priceDate: DateTime(2026, 9, 17),
    priceStatus: priceStatus,
    qty: '100',
    realizedPnlRub: '0',
    ticker: ticker,
    unrealizedPnlNative: valueRub == null ? null : '1000',
    unrealizedPnlRub: valueRub == null ? null : '1000',
    valueNative: valueRub,
    valueRub: valueRub,
    weight: weight,
    xirr: null,
  );
}

SummaryOut summary() => SummaryOut(
  asOf: DateTime(2026, 9, 18),
  cashRub: '5700',
  computedAt: DateTime.utc(2026, 9, 18, 10),
  holdingCount: 2,
  incomeRub: '700',
  investedNetRub: '20000',
  marketValueRub: '11000',
  pnlTotalRub: null,
  realizedPnlRub: '0',
  returns: const [],
  scope: 'all',
  staleCount: 0,
  totalRub: '16700',
  unpricedCount: 1,
);

Widget _wrap(Widget child, List<Override> overrides) => ProviderScope(
  overrides: overrides,
  child: MaterialApp(home: Scaffold(body: child)),
);

/// The tabs are long scrolling lists and a ListView only builds what fits, so the default
/// 800x600 surface would leave the holdings table unbuilt and every `find` on it empty.
Future<void> pumpTall(WidgetTester tester, Widget widget) async {
  tester.view.physicalSize = const Size(1400, 3000);
  tester.view.devicePixelRatio = 1.0;
  addTearDown(tester.view.reset);
  await tester.pumpWidget(widget);
  await tester.pumpAndSettle();
}

void main() {
  testWidgets('Позиции show an unpriced holding as «—», never as 0 ₽', (
    tester,
  ) async {
    await pumpTall(
      tester,
      _wrap(const HoldingsTab(), [
        portfolioSummaryProvider.overrideWith((ref) => Cached(summary())),
        valueSeriesProvider.overrideWith((ref) => const Cached(<ValueDay>[])),
        portfolioReturnsProvider.overrideWith(
          (ref) => const Cached(<ReturnsOut>[]),
        ),
        holdingsProvider.overrideWith(
          (ref) => Cached([
            holding(id: 1, ticker: 'GAZP', valueRub: '11000', weight: '1'),
            holding(id: 2, ticker: 'SIBN6P4', priceStatus: 'missing'),
          ]),
        ),
        // HoldingsTab embeds BenchmarksCard, which watches this too — leaving it out would
        // fall through to the real apiProvider (see docs/ai/offline-cache.md).
        benchmarkRowsProvider.overrideWith(
          (ref) => const Cached(<BenchmarkRow>[]),
        ),
      ]),
    );

    expect(find.text('GAZP'), findsOneWidget);
    expect(find.text('SIBN6P4'), findsOneWidget);
    expect(find.text(MoneyText.format('11000', 'RUB')), findsWidgets);
    // the unpriced row is dashes all the way across — price, value, weight, P&L, XIRR —
    // and nowhere on the screen is an unknown number rendered as 0 ₽
    expect(find.text('—'), findsAtLeastNWidgets(5));
    expect(find.text(MoneyText.format('0', 'RUB')), findsNothing);
  });

  testWidgets('Позиции show the total profit as «—» while a price is missing', (
    tester,
  ) async {
    await pumpTall(
      tester,
      _wrap(const HoldingsTab(), [
        portfolioSummaryProvider.overrideWith((ref) => Cached(summary())),
        valueSeriesProvider.overrideWith((ref) => const Cached(<ValueDay>[])),
        portfolioReturnsProvider.overrideWith(
          (ref) => const Cached(<ReturnsOut>[]),
        ),
        holdingsProvider.overrideWith((ref) => const Cached(<HoldingOut>[])),
        benchmarkRowsProvider.overrideWith(
          (ref) => const Cached(<BenchmarkRow>[]),
        ),
      ]),
    );

    expect(find.text('Прибыль'), findsOneWidget);
    expect(find.text('часть позиций без цены'), findsOneWidget);
  });

  testWidgets('Аллокация labels the cash and unknown buckets in Russian', (
    tester,
  ) async {
    await pumpTall(
      tester,
      _wrap(const AllocationTab(), [
        allocationProvider.overrideWith(
          (ref) => Cached([
            AllocationBucket(
              bucket: 'share',
              dimension: AllocationDimension.assetClass,
              holdingCount: 1,
              valueRub: '11000',
              weight: '0.6587',
            ),
            AllocationBucket(
              bucket: 'cash',
              dimension: AllocationDimension.assetClass,
              holdingCount: 0,
              valueRub: '5700',
              weight: '0.3413',
            ),
          ]),
        ),
      ]),
    );

    expect(find.text('Класс актива'), findsOneWidget);
    expect(find.text('Акции'), findsOneWidget);
    expect(find.text('Денежные средства'), findsOneWidget);
    expect(find.text('65,87 %'), findsOneWidget);
  });

  test('formatPercent keeps null distinct from zero', () {
    expect(formatPercent(null), '—');
    expect(formatPercent('0'), '0,00 %');
    expect(formatPercent('0.1401'), '+14,01 %');
    expect(formatPercent('-0.128'), '-12,80 %');
    expect(formatPercent('0.65', signed: false), '65,00 %');
  });

  test('formatQty trims the NUMERIC(24,10) tail', () {
    expect(formatQty('215.0000000000'), '215');
    expect(formatQty('12.5000000000'), '12,5');
  });

  test('bucketLabel falls back to the source value it does not know', () {
    expect(bucketLabel(AllocationDimension.country, 'RU'), 'Россия');
    expect(bucketLabel(AllocationDimension.country, 'unknown'), 'Не указано');
    expect(
      bucketLabel(AllocationDimension.sector, 'oil_and_gas'),
      'oil_and_gas',
    );
  });
}