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.

15.3 KB
Raw Blame
import 'dart:async';

import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/auth/auth_session.dart';
import 'package:harness/auth/cli_link.dart';
import 'package:harness/core/config.dart';
import 'package:harness/core/models.dart';
import 'package:harness/state/app_state.dart';
import 'package:harness/widgets/link_machine_screen.dart';

import 'keymap_host_test.dart' show key;

class _FakeCliLink implements CliLink {
  final Future<CliLinkConnectResult> Function(String machineId, String password)
  onConnect;
  _FakeCliLink(this.onConnect);

  @override
  Future<CliLinkConnectResult> connect(
    String machineId,
    String password, {
    void Function(String stage)? onProgress,
    String? displayName,
  }) {
    onProgress?.call('exchanging');
    return onConnect(machineId, password);
  }

  @override
  Future<RemotePasswordSetResult> setRemotePassword(String password) async =>
      const RemotePasswordSetResult();

  @override
  Future<RemotePasswordStatus> remotePasswordStatus() async =>
      const RemotePasswordStatus(hasPassword: false);

  @override
  Future<String?> clearRemotePassword() async => null;

  @override
  Future<CliLinkListResult> list() async => const CliLinkListResult();

  @override
  Future<String?> unlink(String machineId) async => null;
}

void main() {
  const machine = Machine(
    machineId: 'remote-1',
    apiKey: '',
    authMode: MachineAuthMode.remote,
    name: 'remote-mac',
    status: 'online',
  );

  AppNotifier notifierFor(_FakeCliLink cliLink) {
    final notifier = AppNotifier(
      config: AppConfig.dev,
      authSession: AuthSession(),
      configStore: null,
      cliLink: cliLink,
    );
    notifier.machines = [machine];
    notifier.machineStates[machine.machineId] = MachineState(machine)
      ..needsLink = true
      ..agentLoadStatus = AgentLoadStatus.needsLink;
    return notifier;
  }

  test(
    'pending handshakes coalesce by machine and ignore a disposed session',
    () async {
      final pending = Completer<CliLinkConnectResult>();
      var calls = 0;
      final notifier = notifierFor(
        _FakeCliLink((_, _) {
          calls++;
          return pending.future;
        }),
      );
      final first = notifier.connectWithPassword(
        machine.machineId,
        'test password',
      );
      final second = notifier.connectWithPassword(
        machine.machineId,
        'another password',
      );
      expect(second, same(first));
      expect(calls, 1);
      expect(notifier.machineLinkStage(machine.machineId), 'exchanging');
      notifier.dispose();
      pending.complete(
        CliLinkConnectResult(linkedMachineId: machine.machineId),
      );
      expect(await first, 'This connection request is no longer active.');
      expect(notifier.machineStates[machine.machineId]!.needsLink, isTrue);
    },
  );

  testWidgets('link prompt accepts typing immediately and submits only once', (
    tester,
  ) async {
    final pending = Completer<CliLinkConnectResult>();
    final passwords = <String>[];
    final notifier = notifierFor(
      _FakeCliLink((_, password) {
        passwords.add(password);
        return pending.future;
      }),
    );
    addTearDown(notifier.dispose);
    await tester.pumpWidget(
      MaterialApp(
        home: Scaffold(
          body: LinkMachineScreen(
            notifier: notifier,
            machineState: notifier.machineStates[machine.machineId]!,
          ),
        ),
      ),
    );
    await tester.pump();
    final field = find.byKey(const Key('remote-password-connect-field'));
    expect(tester.widget<TextField>(field).focusNode?.hasFocus, isTrue);
    tester.testTextInput.enterText('test remote password');
    await tester.testTextInput.receiveAction(TextInputAction.done);
    await tester.testTextInput.receiveAction(TextInputAction.done);
    expect(passwords, ['test remote password']);
    await tester.pump();
    expect(tester.widget<TextField>(field).readOnly, isTrue);
    expect(tester.widget<TextField>(field).focusNode!.hasFocus, isTrue);
    pending.complete(const CliLinkConnectResult(error: 'Incorrect password'));
    await tester.pumpAndSettle();
    expect(tester.widget<TextField>(field).focusNode!.hasFocus, isTrue);
    expect(tester.widget<TextField>(field).readOnly, isFalse);
    expect(
      tester.widget<TextField>(field).controller!.text,
      'test remote password',
    );
    expect(find.text('Incorrect password'), findsOneWidget);
    await tester.pumpWidget(const SizedBox());
  });

  testWidgets('a failed link process unlocks the prompt for keyboard retry', (
    tester,
  ) async {
    var calls = 0;
    final notifier = notifierFor(
      _FakeCliLink((machineId, _) async {
        if (++calls == 1) throw StateError('CLI process failed');
        return CliLinkConnectResult(linkedMachineId: machineId);
      }),
    );
    addTearDown(notifier.dispose);
    await tester.pumpWidget(
      MaterialApp(
        home: Scaffold(
          body: LinkMachineScreen(
            notifier: notifier,
            machineState: notifier.machineStates[machine.machineId]!,
          ),
        ),
      ),
    );
    final field = find.byKey(const Key('remote-password-connect-field'));
    await tester.enterText(field, 'fixture password');
    await key(tester, LogicalKeyboardKey.enter);
    await tester.pumpAndSettle();
    expect(
      find.text('Could not link this machine. Try again.'),
      findsOneWidget,
    );
    expect(notifier.pendingMachineLink(machine.machineId), isNull);
    expect(tester.widget<TextField>(field).readOnly, isFalse);
    expect(tester.widget<TextField>(field).focusNode!.hasFocus, isTrue);
    await key(tester, LogicalKeyboardKey.keyU, ctrl: true);
    expect(tester.widget<TextField>(field).controller!.text, isEmpty);
    expect(find.text('Could not link this machine. Try again.'), findsNothing);
    await key(tester, LogicalKeyboardKey.keyY, ctrl: true);
    expect(
      tester.widget<TextField>(field).controller!.text,
      'fixture password',
    );
    await key(tester, LogicalKeyboardKey.enter);
    await tester.pumpAndSettle();
    expect(calls, 2);
    expect(notifier.machineStates[machine.machineId]!.needsLink, isFalse);
    expect(tester.widget<TextField>(field).controller!.text, isEmpty);
    expect(tester.takeException(), isNull);
    await tester.pumpWidget(const SizedBox());
  });

  test(
    'links to different machines progress and finish independently',
    () async {
      const other = Machine(
        machineId: 'remote-2',
        authMode: MachineAuthMode.remote,
        name: 'remote-server',
      );
      final replies = <String, Completer<CliLinkConnectResult>>{};
      final notifier = notifierFor(
        _FakeCliLink((id, _) => (replies[id] = Completer()).future),
      );
      addTearDown(notifier.dispose);
      notifier.machineStates[other.machineId] = MachineState(other)
        ..needsLink = true;
      final first = notifier.connectWithPassword(machine.machineId, 'first');
      final second = notifier.connectWithPassword(other.machineId, 'second');
      expect(replies.keys, containsAll([machine.machineId, other.machineId]));
      replies[other.machineId]!.complete(
        const CliLinkConnectResult(error: 'Incorrect password'),
      );
      expect(await second, 'Incorrect password');
      expect(notifier.pendingMachineLink(other.machineId), isNull);
      expect(notifier.machineStates[other.machineId]!.needsLink, isTrue);
      expect(notifier.pendingMachineLink(machine.machineId), same(first));
      replies[machine.machineId]!.complete(
        CliLinkConnectResult(linkedMachineId: machine.machineId),
      );
      expect(await first, isNull);
      expect(notifier.pendingMachineLink(machine.machineId), isNull);
      expect(notifier.machineStates[machine.machineId]!.needsLink, isFalse);
    },
  );

  testWidgets('link prompt leaves Enter and Escape with active composition', (
    tester,
  ) async {
    var calls = 0;
    final notifier = notifierFor(
      _FakeCliLink((_, _) async {
        calls++;
        return const CliLinkConnectResult(error: 'Not submitted');
      }),
    );
    addTearDown(notifier.dispose);
    await tester.pumpWidget(
      MaterialApp(
        home: Scaffold(
          body: Builder(
            builder: (context) => TextButton(
              onPressed: () => showLinkMachineScreenDialog(
                context,
                notifier,
                machine.machineId,
              ),
              child: const Text('open'),
            ),
          ),
        ),
      ),
    );
    await tester.tap(find.text('open'));
    await tester.pumpAndSettle();
    final field = find.byKey(const Key('remote-password-connect-field'));
    expect(
      tester.widget<TextField>(field).focusNode!.hasFocus,
      isTrue,
      reason: FocusManager.instance.primaryFocus?.toString(),
    );
    await tester.enterText(field, '日本語');
    final controller = tester.widget<TextField>(field).controller!;
    controller.value = controller.value.copyWith(
      composing: const TextRange(start: 0, end: 3),
    );
    await key(tester, LogicalKeyboardKey.enter);
    await key(tester, LogicalKeyboardKey.escape);
    expect(calls, 0);
    expect(field, findsOneWidget);
    expect(notifier.isLinkPromptDismissed(machine.machineId), isFalse);
    controller.value = controller.value.copyWith(composing: TextRange.empty);
    await key(tester, LogicalKeyboardKey.escape);
    await tester.pumpAndSettle();
    expect(field, findsNothing);
    expect(notifier.isLinkPromptDismissed(machine.machineId), isTrue);
    await tester.pumpWidget(const SizedBox());
  });

  testWidgets(
    'closing and reopening joins the pending link without another request',
    (tester) async {
      final pending = Completer<CliLinkConnectResult>();
      var calls = 0;
      final notifier = notifierFor(
        _FakeCliLink((_, _) {
          calls++;
          return pending.future;
        }),
      );
      addTearDown(notifier.dispose);
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: Builder(
              builder: (context) => TextButton(
                onPressed: () => showLinkMachineScreenDialog(
                  context,
                  notifier,
                  machine.machineId,
                ),
                child: const Text('open'),
              ),
            ),
          ),
        ),
      );
      await tester.tap(find.text('open'));
      await tester.pumpAndSettle();
      final field = find.byKey(const Key('remote-password-connect-field'));
      await tester.enterText(field, 'test password');
      await tester.testTextInput.receiveAction(TextInputAction.done);
      await tester.pump();
      await key(tester, LogicalKeyboardKey.escape);
      await tester.pump();
      await tester.tap(find.text('open'));
      await tester.pump();
      await tester.pump();
      expect(tester.widget<TextField>(field).readOnly, isTrue);
      expect(calls, 1);
      pending.complete(
        const CliLinkConnectResult(error: 'Try another password'),
      );
      await tester.pumpAndSettle();
      expect(find.text('Try another password'), findsOneWidget);
      expect(tester.widget<TextField>(field).readOnly, isFalse);
      expect(tester.widget<TextField>(field).focusNode!.hasFocus, isTrue);
      await key(tester, LogicalKeyboardKey.escape);
      await tester.pumpAndSettle();
      expect(calls, 1);
      await tester.pumpWidget(const SizedBox());
    },
  );

  testWidgets('shows a clear password prompt for the target machine', (
    tester,
  ) async {
    final notifier = notifierFor(
      _FakeCliLink((_, _) async => const CliLinkConnectResult()),
    );
    await tester.pumpWidget(
      MaterialApp(
        home: Scaffold(
          body: LinkMachineScreen(
            notifier: notifier,
            machineState: notifier.machineStates[machine.machineId]!,
          ),
        ),
      ),
    );

    expect(find.text('Link this machine'), findsOneWidget);
    expect(
      find.text('Enter the remote password set on this machine.'),
      findsOneWidget,
    );
    expect(
      find.byKey(const Key('remote-password-connect-field')),
      findsOneWidget,
    );
    expect(find.text('Remote password for remote-mac'), findsOneWidget);
    expect(find.text('Link machine'), findsOneWidget);
    expect(
      find.text(
        'Your previous harness will reconnect automatically after linking.',
      ),
      findsOneWidget,
    );
    expect(find.text('Machine ID: remote-1'), findsNothing);

    await tester.tap(find.byKey(const Key('link-troubleshooting-details')));
    await tester.pump();
    expect(find.text('Machine ID: remote-1'), findsOneWidget);

    // The close key guide remains clickable as well as keyboard accessible.
    expect(find.text('Close'), findsOneWidget);
    notifier.dispose();
  });

  testWidgets('tapping Close dismisses the link prompt', (tester) async {
    final notifier = notifierFor(
      _FakeCliLink((_, _) async => const CliLinkConnectResult()),
    );
    await tester.pumpWidget(
      MaterialApp(
        home: Scaffold(
          body: LinkMachineScreen(
            notifier: notifier,
            machineState: notifier.machineStates[machine.machineId]!,
          ),
        ),
      ),
    );

    expect(notifier.isLinkPromptDismissed(machine.machineId), isFalse);
    await tester.tap(find.text('Close'));
    await tester.pump();
    expect(notifier.isLinkPromptDismissed(machine.machineId), isTrue);
    notifier.dispose();
  });

  testWidgets(
    'submitting a password calls connectWithPassword and clears needsLink on success',
    (tester) async {
      String? connectedPassword;
      final notifier = notifierFor(
        _FakeCliLink((machineId, password) async {
          connectedPassword = password;
          return CliLinkConnectResult(linkedMachineId: machineId);
        }),
      );
      await tester.pumpWidget(
        MaterialApp(
          home: Scaffold(
            body: LinkMachineScreen(
              notifier: notifier,
              machineState: notifier.machineStates[machine.machineId]!,
            ),
          ),
        ),
      );

      await tester.enterText(
        find.byKey(const Key('remote-password-connect-field')),
        'correct horse battery staple',
      );
      await tester.tap(find.text('Link machine'));
      await tester.pumpAndSettle();

      expect(connectedPassword, 'correct horse battery staple');
      expect(notifier.machineStates[machine.machineId]!.needsLink, isFalse);
      notifier.dispose();
    },
  );

  testWidgets('shows the CLI error inline and keeps needsLink on failure', (
    tester,
  ) async {
    final notifier = notifierFor(
      _FakeCliLink(
        (_, _) async => const CliLinkConnectResult(error: 'Incorrect password'),
      ),
    );
    await tester.pumpWidget(
      MaterialApp(
        home: Scaffold(
          body: LinkMachineScreen(
            notifier: notifier,
            machineState: notifier.machineStates[machine.machineId]!,
          ),
        ),
      ),
    );

    await tester.enterText(
      find.byKey(const Key('remote-password-connect-field')),
      'wrong-password',
    );
    await tester.tap(find.text('Link machine'));
    await tester.pumpAndSettle();

    expect(find.text('Incorrect password'), findsOneWidget);
    expect(notifier.machineStates[machine.machineId]!.needsLink, isTrue);
    notifier.dispose();
  });
}