Files
pipelines/app/test/features/chat/conversation/chat_account_usage_test.dart
T
alan 10049b8062 Chat info: account quota per harness (Claude rate_limit_event, Codex account/rateLimits, OpenCode unsupported)
Usage frames carry optional usage.account {harness, source, plan, as_of,
windows[{id,label,used_percent,resets_at}], unsupported}. Claude Code quota
comes from its rate_limit_event stream lines and the initialize account
(plan), shared across chats on the same account. Codex reads
account/rateLimits/read once per connection (re-read when a chat opens after
5 min) and merges account/rateLimits/updated. OpenCode exposes no quota API
and says so. The app's chat info sheet shows an Account usage section with a
progress bar and reset countdown per window, Material and Cupertino.
2026-11-02 18:57:13 +00:00

231 lines
7.6 KiB
Dart

import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/chat/conversation/chat_thread_view.dart';
import 'package:pipelines_app/features/chat/domain/chat_account_usage.dart';
import 'chat_thread_fixtures.dart';
Widget _host(Widget child) => MaterialApp(
theme: ThemeData(platform: TargetPlatform.android),
home: Scaffold(body: child),
);
Widget _cupertinoHost(Widget child) => CupertinoApp(
theme: const CupertinoThemeData(brightness: Brightness.dark),
home: CupertinoPageScaffold(child: child),
);
JsonMap _usageFrame(JsonMap usage) => {
'session_id': 's',
'kind': 'usage',
'usage': usage,
};
/// Synthetic numbers in the server's `usage.account` wire shape.
JsonMap _claudeAccount(DateTime now) => {
'harness': 'Claude Code',
'source': 'rate_limit_event',
'plan': 'max',
'as_of': now.millisecondsSinceEpoch,
'windows': [
{
'id': 'five_hour',
'label': '5-hour',
'used_percent': 42,
'resets_at': now
.add(const Duration(hours: 2, minutes: 14, seconds: 40))
.millisecondsSinceEpoch,
},
{
'id': 'seven_day',
'label': 'Weekly',
'used_percent': 93.4,
'resets_at': now
.add(const Duration(days: 3, hours: 5, minutes: 10))
.millisecondsSinceEpoch,
},
],
};
Future<FakeChatGateway> _thread(
WidgetTester tester, {
bool cupertino = false,
}) async {
final gateway = FakeChatGateway();
addTearDown(gateway.close);
gateway.history = (_) async => chatPage([]);
final thread = ChatThreadView(
gateway: gateway,
sessionId: 's',
onBack: () {},
);
await tester.pumpWidget(cupertino ? _cupertinoHost(thread) : _host(thread));
await tester.pumpAndSettle();
return gateway;
}
Future<void> _openInfo(WidgetTester tester) async {
await tester.tap(find.byKey(const Key('chat-info')));
await tester.pumpAndSettle();
}
void main() {
group('domain', () {
final now = DateTime.utc(2026, 11, 2, 12);
test('parses reported windows and drops unusable ones', () {
final usage = chatAccountUsage({
'harness': 'Codex',
'plan': 'plus',
'as_of': now.millisecondsSinceEpoch,
'windows': [
{'id': 'primary', 'label': '5-hour', 'used_percent': 37},
{'id': 'bad', 'label': 'Bad', 'used_percent': 'x'},
{'id': 'neg', 'label': 'Neg', 'used_percent': -1},
{'id': 'nolabel', 'used_percent': 5},
],
})!;
expect(usage.harness, 'Codex');
expect(usage.windows.map((w) => w.id), ['primary']);
expect(usage.windows.single.resetsAt, 0);
expect(chatQuotaSummary(usage.windows.single, now), '37% used');
});
test('unknown quota is null; an unsupported harness is explicit', () {
expect(chatAccountUsage(null), isNull);
expect(chatAccountUsage({'harness': 'Codex', 'windows': []}), isNull);
final none = chatAccountUsage({
'harness': 'OpenCode',
'unsupported': true,
})!;
expect(none.unsupported, isTrue);
expect(none.harness, 'OpenCode');
});
test('countdown and report age wording', () {
ChatQuotaWindow window(Duration left) => ChatQuotaWindow(
id: 'w',
label: 'W',
usedPercent: 99.6,
resetsAt: now.add(left).millisecondsSinceEpoch,
);
expect(
chatQuotaSummary(window(const Duration(hours: 2, minutes: 14)), now),
'100% used · resets in 2h 14m',
);
expect(
chatQuotaSummary(window(const Duration(minutes: 9)), now),
'100% used · resets in 9m',
);
expect(
chatQuotaSummary(window(const Duration(seconds: 20)), now),
'100% used · resets in under a minute',
);
expect(
chatQuotaSummary(window(const Duration(days: 2, hours: 3)), now),
'100% used · resets in 2d 3h',
);
expect(
chatQuotaSummary(window(const Duration(minutes: -5)), now),
'100% used · reset since this report',
);
final at = now.millisecondsSinceEpoch;
expect(chatQuotaAsOf(at, now), 'as of just now');
expect(chatQuotaAsOf(at - 5 * 60000, now), 'as of 5 min ago');
expect(chatQuotaAsOf(at - 3 * 3600000, now), 'as of 3 h ago');
expect(chatQuotaAsOf(0, now), '');
expect(chatPlanLabel('self_serve_business'), 'Self serve business');
});
});
for (final cupertino in [false, true]) {
final host = cupertino ? 'Cupertino' : 'Material';
testWidgets('$host: account usage shows windows, plan and age', (
tester,
) async {
final gateway = await _thread(tester, cupertino: cupertino);
gateway.emitEvent(
_usageFrame({
'scope': 'session',
'total_tokens': 1200,
'account': _claudeAccount(DateTime.now()),
}),
);
await tester.pump();
await _openInfo(tester);
expect(find.text('Account usage'), findsOneWidget);
expect(find.text('Claude Code · Max plan'), findsOneWidget);
expect(find.text('5-hour'), findsOneWidget);
expect(find.text('42% used · resets in 2h 14m'), findsOneWidget);
expect(find.text('Weekly'), findsOneWidget);
expect(find.text('93% used · resets in 3d 5h'), findsOneWidget);
expect(find.text('as of just now'), findsOneWidget);
final bars = tester
.widgetList<LinearProgressIndicator>(
find.byType(LinearProgressIndicator),
)
.toList();
expect(bars.map((bar) => bar.value), [
closeTo(.42, 1e-9),
closeTo(.934, 1e-9),
]);
expect(bars.first.semanticsLabel, '5-hour quota');
// Token metrics are still shown beside the quota.
expect(find.text('1,200'), findsOneWidget);
});
testWidgets(
'$host: unknown quota hides the section; no-API harness says so',
(tester) async {
final gateway = await _thread(tester, cupertino: cupertino);
gateway.emitEvent(_usageFrame({'scope': 'session', 'total_tokens': 5}));
await tester.pump();
await _openInfo(tester);
expect(find.byKey(const Key('chat-account-usage')), findsNothing);
expect(find.text('Account usage'), findsNothing);
expect(find.byType(LinearProgressIndicator), findsNothing);
gateway.emitEvent(
_usageFrame({
'scope': 'session',
'total_tokens': 6,
'account': {'harness': 'OpenCode', 'unsupported': true},
}),
);
await tester.pumpAndSettle();
expect(find.text('Account usage'), findsOneWidget);
expect(find.text('Not reported by OpenCode'), findsOneWidget);
expect(find.byType(LinearProgressIndicator), findsNothing);
},
);
}
testWidgets('an account-only frame keeps the recorded token metrics', (
tester,
) async {
final gateway = await _thread(tester);
gateway.emitEvent(
_usageFrame({'scope': 'session', 'total_tokens': 132408}),
);
await tester.pump();
gateway.emitEvent(_usageFrame({'account': _claudeAccount(DateTime.now())}));
await tester.pump();
await _openInfo(tester);
expect(find.text('132,408'), findsOneWidget);
expect(find.text('42% used · resets in 2h 14m'), findsOneWidget);
// A later frame without an account keeps the last known quota.
gateway.emitEvent(
_usageFrame({'scope': 'session', 'total_tokens': 140000}),
);
await tester.pumpAndSettle();
expect(find.text('140,000'), findsOneWidget);
expect(find.text('42% used · resets in 2h 14m'), findsOneWidget);
});
}