Loading files
50b3be768This file is pinned to the selected release. Download the original to open it in your design tool.
import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
import 'package:harness/auth/auth_session.dart';
import 'package:harness/core/config.dart';
import 'package:harness/core/models.dart';
import 'package:harness/shared/theme/app_theme.dart' as grid;
import 'package:harness/shared/theme/color_palette.dart';
import 'package:harness/state/app_state.dart';
import 'package:harness/state/terminal_pane.dart';
import 'package:harness/terminal/terminal_theme_store.dart';
import 'package:harness/ws/ws_conn.dart';
const _machine = Machine(
machineId: 'm',
name: 'Fixture computer',
authMode: MachineAuthMode.remote,
status: 'online',
);
const _agents = {
'agents': [
{
'id': 'a',
'name': 'Fixture agent',
'engine': 'codex',
'terminal': {
'runtimes': [
{'backend': 'tmux', 'paneId': '%1'},
],
},
},
],
};
const _capabilities = {
'protocolVersion': 3,
'backend': 'tmux',
'available': true,
};
class _Connection extends WsConn {
_Connection()
: super(
wsBaseUrl: 'ws://fixture.invalid',
autonomousEnv: 'test',
machineId: 'm',
accessTokenProvider: (_, _) async => '',
onAuthFailure: (_) {},
onEvent: (_) {},
onStatus: (_) {},
);
final calls = <String>[];
final agents = <Completer<Map<String, dynamic>>>[];
final capabilities = <Completer<Map<String, dynamic>>>[];
final themes = <Map<String, dynamic>>[];
bool refuseTheme = false;
final timeouts = <String, Duration>{};
final sent = <String>[];
Completer<void>? readiness;
@override
Future<void> waitUntilReady({required Duration timeout}) async {
await readiness?.future;
}
@override
Future<Map<String, dynamic>> request(
String type, {
Map<String, dynamic> payload = const {},
Duration timeout = const Duration(seconds: 20),
}) {
calls.add(type);
timeouts[type] = timeout;
final response = Completer<Map<String, dynamic>>();
switch (type) {
case 'agents_list':
agents.add(response);
case 'terminal_capabilities':
capabilities.add(response);
case 'theme_set':
themes.add(payload);
if (refuseTheme) {
response.completeError(StateError('daemon predates theme_set'));
} else {
response.complete({'applied': true});
}
default:
throw StateError('Unexpected request: $type');
}
return response.future;
}
@override
Future<bool> sendTerminalFrame(
String type,
Map<String, dynamic> payload,
) async {
sent.add(type);
return true;
}
}
Future<void> _tick() => Future<void>.delayed(Duration.zero);
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
late AppNotifier app;
late MachineState machine;
late _Connection connection;
setUp(() {
connection = _Connection();
app = AppNotifier(
config: AppConfig.dev,
authSession: AuthSession(),
connectionForTest: (_) => connection,
)..status = AppStatus.authenticated;
machine = MachineState(_machine)..nodeOnline = true;
app.machines = [_machine];
app.machineStates['m'] = machine;
});
tearDown(() => app.dispose());
test('agent inventory and capabilities are requested together', () async {
final load = app.reloadMachineData('m');
await _tick();
final capabilitiesStarted = connection.capabilities.isNotEmpty;
connection.agents.single.complete(_agents);
await _tick();
connection.capabilities.single.complete(_capabilities);
await load;
expect(capabilitiesStarted, isTrue);
expect(machine.agents.single.id, 'a');
expect(machine.terminalCapabilityAvailable, isTrue);
});
test('agents become visible before a slow capability response', () async {
var sawAgents = false;
app.addListener(() {
if (machine.agents.isNotEmpty) sawAgents = true;
});
final load = app.reloadMachineData('m');
await _tick();
connection.agents.single.complete(_agents);
await _tick();
final visibleBeforeCapabilities = sawAgents;
connection.capabilities.single.complete(_capabilities);
await load;
expect(visibleBeforeCapabilities, isTrue);
expect(machine.agentLoadStatus, AgentLoadStatus.loaded);
});
test('handshake time stays inside the existing inventory budget', () async {
connection.readiness = Completer<void>();
final load = app.reloadMachineData('m');
await Future<void>.delayed(const Duration(milliseconds: 5));
expect(connection.calls, isEmpty);
connection.readiness!.complete();
await _tick();
expect(connection.calls, ['terminal_capabilities', 'agents_list']);
expect(
connection.timeouts['agents_list']!,
lessThan(const Duration(seconds: 10)),
);
expect(connection.timeouts['agents_list']!, greaterThan(Duration.zero));
expect(
connection.timeouts['terminal_capabilities'],
const Duration(seconds: 8),
);
connection.agents.single.complete(_agents);
connection.capabilities.single.complete(_capabilities);
await load;
});
test('repeated reloads share both pending discovery requests', () async {
final first = app.reloadMachineData('m');
final second = app.reloadMachineData('m');
await _tick();
expect(connection.agents, hasLength(1));
expect(connection.capabilities, hasLength(1));
connection.agents.single.complete(_agents);
connection.capabilities.single.complete(_capabilities);
await Future.wait([first, second]);
expect(machine.agentsLoadInFlight, isNull);
expect(machine.terminalCapabilityLoadInFlight, isNull);
});
for (final agentsFirst in [true, false]) {
test(
'restored agent attaches once with ${agentsFirst ? 'agents' : 'capabilities'} first',
() async {
final pane = TerminalPane(id: 99, machineId: 'm', agentId: 'a');
app.activeSwarm.panes.add(pane);
final focus = app.focusedPaneId;
final load = app.reloadMachineData('m');
await _tick();
if (agentsFirst) {
connection.agents.single.complete(_agents);
} else {
connection.capabilities.single.complete(_capabilities);
}
await _tick();
expect(pane.session, isNull);
if (agentsFirst) {
connection.capabilities.single.complete(_capabilities);
} else {
connection.agents.single.complete(_agents);
}
await load;
await _tick();
expect(pane.session, isNotNull);
pane.session!.reportViewport(100, 30);
await _tick();
expect(
connection.sent.where((type) => type == 'terminal_open'),
hasLength(1),
);
expect(app.focusedPaneId, focus);
expect(app.panes.single, same(pane));
},
);
}
test('unavailable capabilities leave discovered agents visible without attaching', () async {
final pane = TerminalPane(id: 99, machineId: 'm', agentId: 'a');
app.activeSwarm.panes.add(pane);
final load = app.reloadMachineData('m');
await _tick();
connection.capabilities.single.completeError(StateError('Unsupported'));
connection.agents.single.complete(_agents);
await load;
expect(machine.agents.single.id, 'a');
expect(machine.agentLoadStatus, AgentLoadStatus.loaded);
expect(machine.terminalCapabilityAvailable, isFalse);
expect(machine.terminalCapabilityError, isNotNull);
expect(pane.session, isNull);
expect(connection.sent, isEmpty);
});
test(
'inventory failure can retry while sharing the pending capability request',
() async {
final failed = app.reloadMachineData('m');
await _tick();
connection.agents.single.completeError(
StateError('Inventory unavailable'),
);
await failed;
expect(machine.agentsLoadError, contains('Inventory unavailable'));
final retry = app.reloadMachineData('m');
await _tick();
expect(connection.capabilities, hasLength(1));
expect(connection.agents, hasLength(2));
connection.capabilities.single.complete(_capabilities);
connection.agents.last.complete(_agents);
await retry;
expect(machine.agentsLoadError, isNull);
expect(machine.terminalCapabilityAvailable, isTrue);
},
);
test('a removed machine cannot send requests after late readiness', () async {
connection.readiness = Completer<void>();
final load = app.reloadMachineData('m');
await _tick();
app.machineStates.clear();
connection.readiness!.complete();
await load;
expect(connection.calls, isEmpty);
expect(app.panes, isEmpty);
});
group('pane colours reach the daemon', () {
tearDown(() {
grid.AppTheme.palette.value = HarnessPalette.graphite;
terminalThemeStore.value = TerminalThemeChoice.matchApp;
});
test('are announced when a machine connects, as the colours the panes are painted with', () async {
grid.AppTheme.palette.value = HarnessPalette.midnight;
app.onMachineConnectedForTest('m');
await _tick();
connection.agents.single.complete(_agents);
await _tick();
connection.capabilities.single.complete(_capabilities);
await _tick();
expect(connection.themes, [
{'background': '#171b29', 'foreground': '#f5f5f5'},
]);
expect(connection.timeouts['theme_set'], const Duration(seconds: 5));
});
test('are re-announced to connected machines when the palette or terminal theme changes', () async {
machine.connectionStatus = ConnectionStatus.connected;
grid.AppTheme.palette.value = HarnessPalette.forest;
await _tick();
// Tango is its own scheme: what goes out is what the pane draws, not the app palette.
terminalThemeStore.value = TerminalThemeChoice.tango;
await _tick();
expect(connection.themes, [
{'background': '#18231e', 'foreground': '#f5f5f5'},
{'background': '#300a24', 'foreground': '#ffffff'},
]);
});
test('a daemon that cannot take the colours is not an error', () async {
connection.refuseTheme = true;
machine.connectionStatus = ConnectionStatus.connected;
grid.AppTheme.palette.value = HarnessPalette.slate;
await _tick();
await _tick();
expect(connection.themes, hasLength(1));
expect(app.lastError, isNull);
});
});
}