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.

12.4 KB
Raw Blame
import 'dart:io';
import 'dart:ui' as ui;

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/screens/swarm_screen.dart';
import 'package:harness/shared/theme/app_theme.dart' as grid;
import 'package:harness/shared/theme/color_palette.dart';
import 'package:harness/shortcuts/app_keymap.dart';
import 'package:harness/state/app_state.dart';
import 'package:harness/state/swarm_catalog.dart';
import 'package:harness/terminal/terminal_binary.dart';
import 'package:harness/terminal/terminal_text.dart';
import 'package:harness/terminal/terminal_theme_store.dart';
import 'package:harness/widgets/search_result_text.dart';
import 'package:harness/widgets/desktop_chrome.dart';
import 'package:harness/widgets/swarm_switcher.dart';
import 'package:xterm/xterm.dart';

import 'keymap_host_test.dart' show MemoryKeymap, key;
import 'box_render_preview_test.dart' show loadPreviewFonts;
import 'support/open_harness.dart';
import 'support/real_fonts.dart';
import 'swarm_screen_test.dart' show terminal;
import 'swarm_state_test.dart' show createApp;

final _input = find.byKey(const ValueKey('swarm-search-input'));
final _panel = find.byKey(const ValueKey('swarm-search-results'));
final _preview = find.byKey(const ValueKey('swarm-search-preview'));

Future<void> _mount(
  WidgetTester tester,
  AppNotifier app,
  MemoryKeymap map,
) async {
  tester.view.devicePixelRatio = 1;
  tester.view.physicalSize = const Size(1280, 800);
  addTearDown(tester.view.resetPhysicalSize);
  addTearDown(tester.view.resetDevicePixelRatio);
  final projects = SwarmProjectStore();
  addTearDown(projects.dispose);
  app.machineStates['m']!.nodeOnline = true;
  await tester.pumpWidget(
    MaterialApp(
      theme: grid.buildAppTheme(brightness: Brightness.dark),
      builder: (_, child) => grid.BrightnessScope(
        child: KeymapProvider(keymap: map, child: child!),
      ),
      home: SwarmScreen(
        notifier: app,
        nativeTabs: false,
        projectStore: projects,
      ),
    ),
  );
  await tester.pump(const Duration(milliseconds: 100));
}

void main() {
  setUpAll(
    Platform.environment['HARNESS_COMMAND_CAPTURE_DIR'] == null
        ? loadRealFonts
        : loadPreviewFonts,
  );

  testWidgets(
    'commands retain the native palette, editor and live appearance',
    (tester) async {
      final originalFont = terminalFontStore.value;
      final originalPalette = grid.AppTheme.palette.value;
      final originalTheme = terminalThemeStore.value;
      addTearDown(() {
        terminalFontStore.value = originalFont;
        grid.AppTheme.palette.value = originalPalette;
        terminalThemeStore.value = originalTheme;
      });
      final app = createApp();
      final map = MemoryKeymap();
      addTearDown(app.dispose);
      addTearDown(map.dispose);
      final frames = <TerminalBinaryFrame>[];
      app.adoptSessionForTest(terminal('a0', frames));
      await _mount(tester, app, map);
      await openHarnessPicker(tester);
      final bounds = tester.getRect(_panel);
      final inputBounds = tester.getRect(_input);
      final editor = tester.state<EditableTextState>(
        find.descendant(of: _input, matching: find.byType(EditableText)),
      );
      final controller = tester.widget<TextField>(_input).controller!;
      final terminalBuffer = tester
          .widget<TerminalView>(find.byType(TerminalView))
          .terminal;

      // Typing a prefix and using the launch shortcut reach the same surface.
      await tester.enterText(_input, '>');
      await tester.pumpAndSettle();
      final search = tester
          .widget<SwarmSearchResults>(find.byType(SwarmSearchResults))
          .search;
      expect(search.isCommandMode, isTrue);
      expect(search.hasPreview, isTrue);
      expect(tester.getRect(_panel).topLeft, bounds.topLeft);
      expect(tester.getRect(_panel).width, bounds.width);
      expect(tester.getRect(_input).topLeft, inputBounds.topLeft);
      expect(tester.getRect(_input).height, inputBounds.height);
      expect(
        tester.state<EditableTextState>(
          find.descendant(of: _input, matching: find.byType(EditableText)),
        ),
        same(editor),
      );
      expect(find.byType(SwarmSearchHints), findsNothing);
      expect(find.byType(SwarmSearchCount), findsNothing);
      expect(
        find.descendant(of: _panel, matching: find.byType(Icon)),
        findsWidgets,
      );
      expect(
        find.descendant(of: _panel, matching: find.byType(ListTile)),
        findsWidgets,
      );

      await tester.enterText(_input, '> new harness');
      await tester.pumpAndSettle();
      final selected = search.selected!;
      expect(selected.commandId, 'agent.new');
      final editing = controller.value;

      void checkAppearance() {
        final field = tester.widget<TextField>(_input);
        final pane = tester.widget<TerminalView>(find.byType(TerminalView));
        final line = find.byKey(ValueKey(selected.id));
        expect(tester.getSize(line).height, greaterThanOrEqualTo(28));
        final surface = find
            .descendant(of: _panel, matching: find.byType(Material))
            .first;
        expect(tester.widget<Material>(surface).color, DesktopChrome.surface);
        expect(field.cursorWidth, 2);
        expect(field.cursorColor, DesktopChrome.foreground);
        final title = find.descendant(
          of: line,
          matching: find.byType(SearchResultText),
        );
        expect(
          tester.getRect(_panel).contains(tester.getCenter(title)),
          isTrue,
        );
        final shortcut = find.descendant(
          of: line,
          matching: find.text(selected.shortcut!),
        );
        expect(tester.widget<Text>(shortcut).data, selected.shortcut);
        final previewText = tester.widgetList<Text>(
          find.descendant(of: _preview, matching: find.byType(Text)),
        );
        expect(
          previewText.map((text) => text.data),
          containsAll([selected.title, selected.detail, selected.shortcut]),
        );
        for (final style in [
          field.style!,
          tester.widget<SearchResultText>(title).style,
        ]) {
          expect(style.fontFamily, DesktopChrome.text().fontFamily);
          expect(style.fontSize, inInclusiveRange(13, 17));
        }
        expect(field.controller, same(controller));
        expect(controller.value, editing);
        expect(field.focusNode!.hasFocus, isTrue);
        expect(search.selected!.id, selected.id);
        expect(pane.terminal, same(terminalBuffer));
        expect(frames, isEmpty);
        expect(tester.takeException(), isNull);
      }

      terminalThemeStore.value = TerminalThemeChoice.matchApp;
      for (final palette in HarnessPalette.values) {
        grid.AppTheme.palette.value = palette;
        await tester.pumpAndSettle();
        checkAppearance();
      }
      terminalThemeStore.value = TerminalThemeChoice.tango;
      terminalFontStore.value = const TerminalStyle(
        fontSize: 18,
        fontFamily: 'Menlo',
        fontFamilyFallback: ['monospace'],
        height: 1.4,
      );
      await tester.pumpAndSettle();
      checkAppearance();

      // Empty results never show a stale command preview or execute it.
      await tester.enterText(_input, '> no-such-command-923');
      await tester.pumpAndSettle();
      expect(search.selected, isNull);
      expect(find.text('No matching commands'), findsOneWidget);
      expect(
        find.descendant(of: _preview, matching: find.byType(Text)),
        findsNothing,
      );
      await key(tester, LogicalKeyboardKey.enter);
      expect(_input, findsOneWidget);
      await tester.enterText(_input, '');
      await tester.pumpAndSettle();
      expect(search.isCommandMode, isFalse);
      expect(tester.getRect(_panel), bounds);
      expect(controller.text, isEmpty);
      expect(
        find.byKey(const ValueKey('search-category-Machines')),
        findsOneWidget,
      );
      await key(tester, LogicalKeyboardKey.escape);
      final linux = defaultTargetPlatform == TargetPlatform.linux;
      await key(
        tester,
        LogicalKeyboardKey.keyP,
        cmd: !linux,
        ctrl: linux,
        shift: true,
      );
      expect(tester.widget<TextField>(_input).controller!.text, '>');
      expect(tester.getRect(_panel).topLeft, bounds.topLeft);
      expect(tester.getRect(_panel).width, bounds.width);
      expect(frames, isEmpty);
      await tester.pumpWidget(const SizedBox());
    },
    variant: TargetPlatformVariant({
      TargetPlatform.macOS,
      TargetPlatform.linux,
    }),
  );

  for (final size in [const Size(1280, 800), const Size(400, 600)]) {
    testWidgets('commands page and preview fit the native palette at $size', (
      tester,
    ) async {
      final originalFont = terminalFontStore.value;
      addTearDown(() => terminalFontStore.value = originalFont);
      if (size.width < 800) {
        terminalFontStore.value = const TerminalStyle(
          fontSize: 22,
          fontFamily: 'Menlo',
          height: 1.4,
        );
      }
      final app = createApp();
      final map = MemoryKeymap();
      addTearDown(app.dispose);
      addTearDown(map.dispose);
      app.adoptSessionForTest(terminal('a0', []));
      await _mount(tester, app, map);
      tester.view.physicalSize = size;
      await tester.pump();
      await key(tester, LogicalKeyboardKey.keyP, cmd: true, shift: true);
      final search = tester
          .widget<SwarmSearchResults>(find.byType(SwarmSearchResults))
          .search;
      final field = tester.widget<TextField>(_input);
      final value = field.controller!.value;
      final first = search.cursor;
      await key(tester, LogicalKeyboardKey.pageDown);
      expect(search.cursor, greaterThan(first + 1));
      await key(tester, LogicalKeyboardKey.pageUp);
      expect(search.cursor, first);
      await key(tester, LogicalKeyboardKey.tab);
      expect(search.cursor, first);
      expect(field.focusNode!.hasFocus, isFalse);
      await key(tester, LogicalKeyboardKey.tab, shift: true);
      expect(field.focusNode!.hasFocus, isTrue);
      expect(
        find.byKey(const ValueKey('swarm-search-resource-actions')),
        findsNothing,
      );
      await key(tester, LogicalKeyboardKey.arrowDown);
      expect(search.cursor, first + 1);
      expect(field.controller!.value, value);
      expect(field.focusNode!.hasFocus, isTrue);
      final list = find.byKey(const ValueKey('swarm-search-result-list'));
      expect(
        size.width > 800
            ? tester.getRect(_preview).left > tester.getRect(list).right
            : tester.getRect(_preview).top > tester.getRect(list).bottom,
        isTrue,
      );
      await tester.enterText(_input, '> new harness');
      await tester.pumpAndSettle();
      map.apply('''{"bindings":[
        {"keys":"cmd+n","command":null},
        {"keys":"ctrl+shift+alt+x ctrl+shift+alt+y","command":"agent.new"}
      ]}''');
      await tester.pumpAndSettle();
      final shortcut = map.hint('agent.new');
      expect(search.selected!.shortcut, shortcut);
      expect(
        find.descendant(of: _preview, matching: find.text(shortcut!)),
        findsOneWidget,
      );
      expect(field.controller!.text, '> new harness');
      expect(tester.takeException(), isNull);
      map.apply('{"bindings":[]}');
      await tester.enterText(_input, '?');
      await tester.pumpAndSettle();
      expect(search.hasPreview, isTrue);
      expect(find.text('No recent harness text available.'), findsNothing);
      expect(
        tester.widget<TextField>(_input).controller,
        same(field.controller),
      );
      await tester.enterText(_input, '> new');
      await tester.pumpAndSettle();
      final directory = Platform.environment['HARNESS_COMMAND_CAPTURE_DIR'];
      if (directory != null) {
        final layer =
            tester.binding.renderViews.first.debugLayer! as OffsetLayer;
        final rect = tester.getRect(_panel);
        await tester.runAsync(() async {
          final image = await layer.toImage(rect);
          final data = await image.toByteData(format: ui.ImageByteFormat.png);
          await Directory(directory).create(recursive: true);
          await File('$directory/commands-${size.width.toInt()}.png')
              .writeAsBytes(data!.buffer.asUint8List());
          image.dispose();
        });
      }
      expect(tester.takeException(), isNull);
      await tester.pumpWidget(const SizedBox());
    });
  }
}