Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

8.2 KB
Raw Blame
import 'dart:async';

import 'package:flutter_test/flutter_test.dart';
import 'package:harness_mobile/usage/models_menu_controller.dart';
import 'package:harness_mobile/usage/usage_accounts.dart';
import 'package:harness_mobile/usage/usage_controller.dart';
import 'package:harness_mobile/usage/usage_window.dart';

/// The model sheet's first row: what this agent's own subscription has left.
///
/// A figure there is read at a glance while choosing where an agent runs, so
/// the row must never print a number it cannot stand behind — an old reading,
/// a window that has since reset, a refresh that failed — as if it were live.
void main() {
  late DateTime now;

  setUp(() => now = DateTime(2026, 9, 27, 12));

  ProviderUsage reading({
    UsageProvider provider = UsageProvider.claude,
    List<UsageWindow>? windows,
    String? account,
    Duration age = const Duration(seconds: 30),
  }) => ProviderUsage(
    provider: provider,
    status: UsageStatus.ok,
    account: account,
    fetchedAt: now.subtract(age),
    windows:
        windows ??
        [
          UsageWindow(
            label: 'Session',
            usedPercent: 71,
            resetsAt: now.add(const Duration(hours: 2, minutes: 5)),
          ),
          const UsageWindow(label: kWeeklyWindowLabel, usedPercent: 40),
        ],
  );

  /// A controller over one machine whose answer is [answer], asked with a
  /// clock the test moves.
  ModelsMenuController menu(
    List<ProviderUsage> Function() answer, {
    void Function()? onAsk,
  }) {
    final controller = ModelsMenuController(
      remote: () async {
        onAsk?.call();
        return [MachineUsage(machineName: 'Studio', readings: answer())];
      },
      now: () => now,
    );
    addTearDown(controller.dispose);
    return controller;
  }

  test('nothing to show before the first refresh', () {
    expect(menu(() => [reading()]).rows, isEmpty);
  });

  test(
    'a live figure: what the limiting window has left, then each one',
    () async {
      final controller = menu(() => [reading(account: '0123456789abcdef')]);
      await controller.refresh();
      final row = controller.rows.single;
      expect(row['title'], 'Anthropic');
      expect(row['engine'], 'claude');
      // The opaque account key, shortened — never an email.
      expect(row['account'], '012345');
      // The SESSION window: the weekly one reads healthier while the shorter
      // window is what stops work first.
      expect(row['status'], '29% remaining');
      expect(row['details'], [
        'Limiting window: Session',
        'Session — 29% remaining · resets in 2h 5m',
        'Weekly — 60% remaining',
      ]);
    },
  );

  test(
    'Codex rows are OpenAI\'s, and a key that is not ours shows nothing',
    () async {
      final controller = menu(
        () => [reading(provider: UsageProvider.codex, account: '[email protected]')],
      );
      await controller.refresh();
      final row = controller.rows.single;
      expect(row['title'], 'OpenAI');
      expect(row['engine'], 'codex');
      expect(row['iconAsset'], 'assets/engine-icons/codex.png');
      expect(row['account'], '');
    },
  );

  test('a sliver left is "<1%", never rounded down to nothing', () async {
    final controller = menu(
      () => [
        reading(
          windows: const [UsageWindow(label: 'Weekly', usedPercent: 99.6)],
        ),
      ],
    );
    await controller.refresh();
    expect(controller.rows.single['status'], '<1% remaining');
  });

  test(
    'a spent window is 0%, and a partial balance never reads 100%',
    () async {
      final controller = menu(
        () => [
          reading(
            windows: const [
              UsageWindow(label: 'Session', usedPercent: 100),
              UsageWindow(label: 'Weekly', usedPercent: 0.4),
            ],
          ),
        ],
      );
      await controller.refresh();
      expect(controller.rows.single['details'], [
        'Limiting window: Session',
        'Session — 0% remaining',
        'Weekly — 99% remaining',
      ]);
    },
  );

  group('a reading that can no longer be stood behind', () {
    test('older than two minutes: unavailable, and says why', () async {
      final controller = menu(() => [reading(age: const Duration(minutes: 3))]);
      await controller.refresh();
      final row = controller.rows.single;
      expect(row['status'], 'Usage unavailable');
      expect(row['details'], [
        'The last reading has expired. Reopen Models to refresh.',
      ]);
    });

    test('a window whose reset has passed since it was read', () async {
      final controller = menu(
        () => [
          reading(
            windows: [
              UsageWindow(
                label: 'Session',
                usedPercent: 71,
                resetsAt: now.add(const Duration(seconds: 30)),
              ),
            ],
          ),
        ],
      );
      await controller.refresh();
      expect(controller.rows.single['status'], '29% remaining');
      // The reading is barely a minute old, but the session window reset
      // after it was taken: its 71% describes a window that is gone.
      now = now.add(const Duration(seconds: 45));
      expect(controller.rows.single['status'], 'Usage unavailable');
    });

    test(
      'a refresh that threw: unavailable, with no raw error in it',
      () async {
        final usage = _ThrowingUsage();
        final controller = ModelsMenuController(usage: usage, now: () => now);
        addTearDown(() {
          controller.dispose();
          usage.dispose();
        });
        await controller.refresh();
        final row = controller.rows.single;
        expect(row['status'], 'Usage unavailable');
        expect(row['details'], ['Usage unavailable']);
        expect('$row', isNot(contains('secret-token')));
      },
    );
  });

  group('refresh', () {
    test('at most once a minute; the cache answers in between', () async {
      var asked = 0;
      final controller = menu(() => [reading()], onAsk: () => asked++);
      await controller.refresh();
      await controller.refresh();
      expect(asked, 1);
      now = now.add(const Duration(minutes: 1));
      await controller.refresh();
      expect(asked, 2);
    });

    test('a refresh already on its way is shared, not repeated', () async {
      var asked = 0;
      final gate = Completer<void>();
      final controller = ModelsMenuController(
        remote: () async {
          asked++;
          await gate.future;
          return [
            MachineUsage(machineName: 'Studio', readings: [reading()]),
          ];
        },
        now: () => now,
      );
      addTearDown(controller.dispose);
      var notified = 0;
      controller.addListener(() => notified++);
      final first = controller.refresh();
      final second = controller.refresh();
      expect(identical(first, second), isTrue);
      gate.complete();
      await first;
      expect(asked, 1);
      expect(notified, greaterThanOrEqualTo(2));
    });

    test('after the sheet closed, nothing is asked', () async {
      var asked = 0;
      final controller = ModelsMenuController(
        remote: () async {
          asked++;
          return const <MachineUsage>[];
        },
        now: () => now,
      );
      controller.dispose();
      await controller.refresh();
      expect(asked, 0);
    });

    test('a controller handed in is left for its owner to dispose', () async {
      final usage = UsageController(autoStart: false);
      final controller = ModelsMenuController(usage: usage, now: () => now);
      controller.dispose();
      // Still usable: disposing it would throw on the listener below.
      usage.addListener(() {});
      usage.dispose();
    });
  });
}

/// A usage source whose refresh throws something that must never reach the
/// menu — an exception can carry authentication data.
class _ThrowingUsage extends UsageController {
  _ThrowingUsage() : super(autoStart: false);

  @override
  List<UsageAccount> get accounts => [
    UsageAccount(
      reading: ProviderUsage(
        provider: UsageProvider.claude,
        status: UsageStatus.ok,
        fetchedAt: DateTime(2026, 9, 27, 12),
        windows: const [UsageWindow(label: 'Weekly', usedPercent: 10)],
      ),
      isLocal: false,
    ),
  ];

  @override
  Future<void> refresh() async => throw StateError('secret-token');
}