test: add more unit tests

Author: GregoryConrad

test/crate_resolver_test.dart

@@ -0,0 +1,61 @@
+import 'dart:io';
+
+import 'package:native_toolchain_rs/src/crate_resolver.dart';
+import 'package:native_toolchain_rs/src/exception.dart';
+import 'package:path/path.dart' as path;
+import 'package:test/test.dart';
+
+void main() {
+  group('CrateDirectoryResolver', () {
+    late Directory tempDir;
+    const resolver = CrateDirectoryResolver();
+
+    setUp(() {
+      tempDir = Directory.systemTemp.createTempSync('crate_resolver_test');
+    });
+
+    tearDown(() {
+      tempDir.deleteSync(recursive: true);
+    });
+
+    test('resolveCrateDirectory returns the correct directory', () {
+      final crateDir = Directory(path.join(tempDir.path, 'crate'))
+        ..createSync();
+
+      final result = resolver.resolveCrateDirectory(
+        rootPath: tempDir.path,
+        cratePathOptions: ['crate'],
+      );
+
+      expect(result.path, equals(crateDir.path));
+    });
+
+    test(
+      'resolveCrateDirectory throws RustValidationException '
+      'if no directory exists',
+      () {
+        expect(
+          () => resolver.resolveCrateDirectory(
+            rootPath: tempDir.path,
+            cratePathOptions: ['non_existent_crate'],
+          ),
+          throwsA(isA<RustValidationException>()),
+        );
+      },
+    );
+
+    test('resolveCrateDirectory returns the first existing directory', () {
+      final crateDir1 = Directory(path.join(tempDir.path, 'crate1'));
+      final crateDir2 = Directory(path.join(tempDir.path, 'crate2'));
+      crateDir1.createSync();
+      crateDir2.createSync();
+
+      final result = resolver.resolveCrateDirectory(
+        rootPath: tempDir.path,
+        cratePathOptions: ['crate1', 'crate2'],
+      );
+
+      expect(result.path, equals(crateDir1.path));
+    });
+  });
+}

test/exception_test.dart

@@ -0,0 +1,40 @@
+import 'package:native_toolchain_rs/src/exception.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('RustValidationException', () {
+    test('compose returns results when no exceptions are thrown', () {
+      final results = RustValidationException.compose([
+        () => 1,
+        () => 2,
+      ]);
+      expect(results, equals([1, 2]));
+    });
+
+    test('compose throws aggregate exception', () {
+      expect(
+        () => RustValidationException.compose([
+          () => throw const RustValidationException(['error1']),
+          () => 1,
+          () => throw const RustValidationException(['error2', 'error3']),
+        ]),
+        throwsA(
+          isA<RustValidationException>().having(
+            (e) => e.validationErrors,
+            'validationErrors',
+            equals(['error1', 'error2', 'error3']),
+          ),
+        ),
+      );
+    });
+
+    test('compose does not catch other exceptions', () {
+      expect(
+        () => RustValidationException.compose([
+          () => throw Exception('some other error'),
+        ]),
+        throwsA(isA<Exception>()),
+      );
+    });
+  });
+}

test/process_runner_test.dart

@@ -0,0 +1,40 @@
+import 'dart:io';
+
+import 'package:logging/logging.dart';
+import 'package:native_toolchain_rs/src/exception.dart';
+import 'package:native_toolchain_rs/src/process_runner.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('ProcessRunner', () {
+    late ProcessRunner processRunner;
+    late List<LogRecord> records;
+
+    setUp(() {
+      records = [];
+      final logger = Logger.detached('test')..onRecord.listen(records.add);
+      processRunner = ProcessRunner(logger);
+    });
+
+    test('invoke succeeds with exit code 0', () async {
+      final result = await processRunner.invoke('echo', ['hello']);
+      expect(result.trim(), equals('hello'));
+      expect(records, hasLength(1));
+      expect(records.single.message, contains('Invoking "echo [hello]'));
+    });
+
+    test('invoke throws RustProcessException on non-zero exit code', () {
+      expect(
+        () => processRunner.invoke('dart', ['run', 'non_existent_file.dart']),
+        throwsA(isA<RustProcessException>()),
+      );
+    });
+
+    test('invoke throws ProcessException on command not found', () {
+      expect(
+        () => processRunner.invoke('command_not_found', []),
+        throwsA(isA<ProcessException>()),
+      );
+    });
+  });
+}