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.

11.5 KB
Raw Blame
import 'dart:async';
import 'dart:convert';
import 'dart:io';

import 'package:flutter_test/flutter_test.dart';
import 'package:harness/auth/cli_login.dart';
import 'package:harness/auth/sign_in_client.dart';
import 'package:harness/auth/sign_in_provider.dart';
import 'package:harness/core/harness_cli_runner.dart';

import 'swarm_state_test.dart' show createApp;

class _Runner extends HarnessCliRunner {
  _Runner({this.method = const []});

  /// The flag naming how to sign in (`--google`, `--apple`), when the test's sign-in names one.
  final List<String> method;
  final starts = <Completer<Process>>[];
  @override
  Future<Process> start(List<String> arguments) {
    // The entry point rides along: login tracking tells an app sign-in from a terminal one by
    // it, and the CLI signs in as the desktop app's own auth-service client because of it.
    expect(arguments, [
      'login',
      '--force',
      '--json',
      ...method,
      '--entry-point=desktop',
    ]);
    final start = Completer<Process>();
    starts.add(start);
    return start.future;
  }
}

class _Process implements Process {
  final output = StreamController<List<int>>();
  final errors = StreamController<List<int>>();
  final ended = Completer<int>();
  var kills = 0;
  void emit(Map<String, dynamic> event) =>
      output.add(utf8.encode('${jsonEncode(event)}\n'));
  void finish([int exitCode = 0]) {
    unawaited(output.close());
    unawaited(errors.close());
    if (!ended.isCompleted) ended.complete(exitCode);
  }

  @override
  Stream<List<int>> get stdout => output.stream;
  @override
  Stream<List<int>> get stderr => errors.stream;
  @override
  Future<int> get exitCode => ended.future;
  @override
  bool kill([ProcessSignal signal = ProcessSignal.sigterm]) {
    kills++;
    // A signalled process need not exit synchronously. Tests explicitly finish
    // it later, including after a replacement sign-in has already started.
    return true;
  }

  @override
  int get pid => 1;
  @override
  IOSink get stdin => throw UnimplementedError();
}

class _LogoutRunner extends HarnessCliRunner {
  _LogoutRunner(this.process)
    : super(runTimeout: const Duration(milliseconds: 30));
  final _Process process;
  final arguments = <List<String>>[];
  @override
  Future<Process> start(List<String> command) async {
    arguments.add(command);
    return process;
  }

  @override
  Future<ProcessResult> run(List<String> command) async {
    // The original fire-and-forget run path reports this as success.
    return ProcessResult(1, 1, '', 'Fixture failure');
  }
}

class _TimeoutProcess extends _Process {
  @override
  bool kill([ProcessSignal signal = ProcessSignal.sigterm]) {
    final killed = super.kill(signal);
    finish(1);
    return killed;
  }
}

void main() {
  // 10-27: a test signed the app out with no fake sign-in client, which ran the
  // real `harness logout` and signed the whole Mac out, again on every run.
  group('under flutter test, with no runner given', () {
    /// What [body] threw, and the errors it reported to its zone, where the
    /// test framework fails the test on them.
    Future<(Object?, List<Object>)> guarded(Future<void> Function() body) {
      final reported = <Object>[];
      final done = Completer<Object?>();
      runZonedGuarded(() async {
        try {
          await body();
          done.complete(null);
        } catch (error) {
          done.complete(error);
        }
      }, (error, _) => reported.add(error));
      return done.future.then((thrown) => (thrown, reported));
    }

    test('it never runs the real CLI: it reads as no CLI here', () async {
      await expectLater(
        CliLogin().checkStatus(),
        throwsA(isA<CliNotAvailableException>()),
      );
    });

    test('signing out fails the test loudly, and runs nothing', () async {
      final (thrown, reported) = await guarded(() => CliLogin().logout());

      expect(thrown, isA<CliSignOutUnderTestError>());
      expect(reported, [isA<CliSignOutUnderTestError>()]);
    });

    test('an app signed out with no fake sign-in client fails the test '
        'loudly', () async {
      final app = createApp();
      addTearDown(app.dispose);

      final (_, reported) = await guarded(app.logout);

      expect(reported, [isA<CliSignOutUnderTestError>()]);
      expect(
        reported.single.toString(),
        contains('would sign this computer out'),
      );
    });
  });

  test('logout reports a nonzero CLI exit as a failure', () async {
    final process = _Process()..finish(1);
    final runner = _LogoutRunner(process);
    await expectLater(CliLogin(runner: runner).logout(), throwsStateError);
  });

  test(
    'logout drains output and finishes before permitting another command',
    () async {
      final process = _Process();
      final runner = _LogoutRunner(process);
      var finished = false;
      final pending = CliLogin(runner: runner)
          .logout()
          .then((_) => finished = true);
      await Future<void>.delayed(Duration.zero);
      expect(finished, isFalse);
      process.emit({'fixture': 'output'});
      process.errors.add(utf8.encode('fixture diagnostic'));
      process.finish();
      await pending;
      // A person asked, with the app's Sign out button: the CLI refuses a sign-out nothing says a
      // person asked for (10-27).
      expect(runner.arguments, [
        ['logout', '--from-sign-out-button'],
      ]);
    },
  );

  test(
    'a timed-out logout stops its process before returning failure',
    () async {
      final process = _TimeoutProcess();
      final runner = _LogoutRunner(process);
      await expectLater(CliLogin(runner: runner).logout(), throwsStateError);
      expect(process.kills, 1);
      expect(process.ended.isCompleted, isTrue);
    },
  );

  for (final provider in SignInProvider.values) {
    test(
      '${provider.label} is one flag to the CLI, and its page still arrives',
      () async {
        final runner = _Runner(method: ['--${provider.name}']);
        final cli = CliLogin(runner: runner);
        final urls = <String>[];
        final login = cli.login(onAuthorizeUrl: urls.add, provider: provider);
        final process = _Process();
        process.emit({
          'type': 'authorize_url',
          'url': 'https://auth.example/page',
        });
        process.emit({'type': 'result', 'status': 'success'});
        runner.starts.single.complete(process);
        process.finish();
        await login;
        expect(urls, ['https://auth.example/page']);
      },
    );
  }

  test(
    'cancel while the CLI starts ignores its late URL and stops that process',
    () async {
      final runner = _Runner();
      final cli = CliLogin(runner: runner);
      final urls = <String>[];
      final login = cli.login(onAuthorizeUrl: urls.add);
      final result = expectLater(login, throwsStateError);
      cli.cancel();
      final process = _Process();
      process.emit({
        'type': 'authorize_url',
        'url': 'https://auth.example/old',
      });
      process.emit({'type': 'result', 'status': 'success'});
      runner.starts.single.complete(process);
      process.finish();
      await result;
      expect(process.kills, 1);
      expect(urls, isEmpty);
    },
  );

  test(
    'a cancelled process cannot clear or complete its replacement',
    () async {
      final runner = _Runner();
      final cli = CliLogin(runner: runner);
      final urls = <String>[];
      final first = cli.login(onAuthorizeUrl: urls.add);
      final firstResult = expectLater(first, throwsStateError);
      final old = _Process();
      runner.starts.first.complete(old);
      await Future<void>.delayed(Duration.zero);
      cli.cancel();
      final second = cli.login(onAuthorizeUrl: urls.add);
      final secondResult = expectLater(second, throwsStateError);
      final current = _Process();
      runner.starts.last.complete(current);
      await Future<void>.delayed(Duration.zero);
      old.emit({'type': 'authorize_url', 'url': 'https://auth.example/old'});
      old.emit({'type': 'result', 'status': 'success'});
      old.finish();
      await firstResult;
      expect(urls, isEmpty);
      cli.cancel();
      expect(current.kills, 1);
      current.finish();
      await secondResult;
    },
  );

  test(
    'successful CLI sign-in still publishes its URL and completes',
    () async {
      final runner = _Runner();
      final cli = CliLogin(runner: runner);
      final urls = <String>[];
      final login = cli.login(onAuthorizeUrl: urls.add);
      final process = _Process();
      runner.starts.single.complete(process);
      process.emit({
        'type': 'authorize_url',
        'url': 'https://auth.example/current',
      });
      process.emit({'type': 'result', 'status': 'success'});
      process.finish();
      await login;
      cli.cancel();
      expect(urls, ['https://auth.example/current']);
      expect(process.kills, 0);
    },
  );

  test(
    'a coded CLI refusal reaches the app with its code and sentence',
    () async {
      final runner = _Runner();
      final cli = CliLogin(runner: runner);
      final login = cli.login(onAuthorizeUrl: (_) {});
      final process = _Process();
      runner.starts.single.complete(process);
      process.emit({
        'type': 'result',
        'status': 'error',
        'code': 'TIMEOUT',
        'message': 'SSO login timed out',
      });
      process.finish(1);
      await expectLater(
        login,
        throwsA(
          isA<SignInException>()
              .having((e) => e.code, 'code', 'TIMEOUT')
              .having((e) => e.toString(), 'sentence', 'SSO login timed out'),
        ),
      );
    },
  );

  test(
    'a CLI that ends without a result line is reported as no result',
    () async {
      final runner = _Runner();
      final cli = CliLogin(runner: runner);
      final login = cli.login(onAuthorizeUrl: (_) {});
      final process = _Process();
      runner.starts.single.complete(process);
      process.finish(1);
      await expectLater(
        login,
        throwsA(
          isA<SignInException>()
              .having((e) => e.code, 'code', 'NO_RESULT')
              .having(
                (e) => e.toString(),
                'sentence',
                'Sign-in was cancelled.',
              ),
        ),
      );
    },
  );

  group('CliAuthStatus.fromJson', () {
    test('parses a full logged-in payload', () {
      final status = CliAuthStatus.fromJson({
        'loggedIn': true,
        'computerId': 'a' * 32,
        'machineId': 'm_123',
        'autonomousEnv': 'prod',
        'expiresAt': 1234567890,
      });
      expect(status.loggedIn, isTrue);
      expect(status.computerId, 'a' * 32);
      expect(status.machineId, 'm_123');
      expect(status.autonomousEnv, 'prod');
    });

    test('reads the CLI\'s offline flag: signed in, backend out of reach', () {
      final status = CliAuthStatus.fromJson({
        'loggedIn': true,
        'offline': true,
        'machineId': 'm_123',
      });
      expect(status.loggedIn, isTrue);
      expect(status.offline, isTrue);
      expect(CliAuthStatus.fromJson({'loggedIn': true}).offline, isFalse);
    });

    test('parses a logged-out payload with no other fields', () {
      final status = CliAuthStatus.fromJson({'loggedIn': false});
      expect(status.loggedIn, isFalse);
      expect(status.computerId, isNull);
      expect(status.machineId, isNull);
      expect(status.autonomousEnv, isNull);
    });

    test('treats a missing/non-true loggedIn field as logged out', () {
      expect(CliAuthStatus.fromJson({}).loggedIn, isFalse);
      expect(CliAuthStatus.fromJson({'loggedIn': 'true'}).loggedIn, isFalse);
    });
  });
}