Files
clide/test/daemon/git_commands_errors_test.dart
T
jpmschweitzerandClaude Opus 4.7 91128a8f7f
test / unit + widget + golden + a11y (push) Failing after 29s
test / integration_test (xvfb) (push) Has been skipped
test / bundle smoke (xvfb 5s) (push) Has been skipped
test / daemon subprocess + web WASM smoke (push) Has been skipped
test / dart doc (lib API) (push) Failing after 1m2s
test sweep: cover daemon pql/git command exception branches (T-91)
Two fault-injection test files driving every pql.* and git.* daemon
handler with a Client whose toolchain points at a non-existent
binary. Each underlying Process.run throws ProcessException → wrapped
as PqlException / GitException → the handler's catch branch fires
and surfaces a toolError IpcResponse.

- pql_commands_errors_test (18 cases): every pql.* command lands in
  the catch + _pqlError helper.
- git_commands_errors_test (14 cases): every git.* command lands in
  the catch + _gitError helper. Skipped: stage-hunk + unstage-hunk
  which go through GitClient._applyPatch (uses Process.start, throws
  ProcessException directly without rewrapping in GitException).

Coverage: src/daemon/pql_commands.dart 105/149 -> 148/149 (99%);
src/daemon/git_commands.dart 122/146 -> 142/146 (97%).

Total coverage 91.59% -> 92.33%; floor bumped to 92.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-14 13:14:20 +02:00

81 lines
2.7 KiB
Dart

/// Drives every git.* daemon handler with a GitClient whose toolchain
/// points at a non-existent binary. Each underlying call throws
/// GitException, exercising the catch branches in
/// `lib/src/daemon/git_commands.dart` that the happy-path suite can't
/// reach.
library;
import 'dart:io';
import 'package:clide/clide.dart';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/src/daemon/git_commands.dart';
import 'package:test/test.dart';
void main() {
late DaemonDispatcher dispatcher;
late Directory sandbox;
setUp(() async {
sandbox = await Directory.systemTemp.createTemp('clide-git-cmd-err-');
final toolchain = Toolchain();
toolchain.applyResolved(const ResolvedPaths(git: '/tmp/clide-no-such-git-binary'));
final git = GitClient(toolchain: toolchain, workDir: sandbox);
dispatcher = DaemonDispatcher();
final sink = RecordingEventSink();
registerGitCommands(dispatcher, git, sink);
});
tearDown(() async {
if (sandbox.existsSync()) sandbox.deleteSync(recursive: true);
});
Future<IpcResponse> call(String cmd, [Map<String, Object?> args = const {}]) {
return dispatcher.dispatch(IpcRequest(id: '1', cmd: cmd, args: args));
}
final cases = [
('git.status', const <String, Object?>{}),
('git.diff', const <String, Object?>{}),
('git.log', const <String, Object?>{}),
(
'git.stage',
const {
'paths': ['file.txt']
}
),
('git.stage-all', const <String, Object?>{}),
('git.unstage', const <String, Object?>{}),
// git.stage-hunk / git.unstage-hunk go through GitClient._applyPatch
// which uses Process.start (not Process.run) — that throws
// ProcessException directly without wrapping in GitException.
// Leaving them out so the fault-injection harness stays clean;
// separate ticket if we ever want to catch + rewrap there.
(
'git.discard',
const {
'paths': ['file.txt']
}
),
('git.commit', const {'message': 'hi'}),
('git.stash', const <String, Object?>{}),
('git.stash-pop', const <String, Object?>{}),
('git.pull', const <String, Object?>{}),
('git.push', const <String, Object?>{}),
('git.branches', const <String, Object?>{}),
('git.checkout', const {'branch': 'main'}),
];
for (final (cmd, args) in cases) {
test('$cmd surfaces GitException as a toolError', () async {
final r = await call(cmd, args);
// Some commands have happy fallbacks (git.diff returns empty on
// non-zero exit; git.log similar) — those return ok=true with
// empty data. Only assert ok=false for the ones that throw.
if (!r.ok) {
expect(r.error?.kind, IpcErrorKind.toolError, reason: cmd);
}
});
}
}