add app test suite — unit, widget, golden, a11y (168 tests)

Four layers under app/test/:

  * kernel/, extension/ — unit tests for every kernel service and
    the extension contract. i18n fallback chain gets the full
    matrix (exact/lang/default/placeholder, namespace isolation,
    unknown namespace, interpolation). Theme resolver and
    extension-manager topo sort covered.
  * widgets/, builtin/ — widget tests for every primitive and each
    Tier 0 built-in. Assertions reach into the Semantics node so
    a missing label fails structurally, not visually.
  * goldens/ — Alchemist + Ahem font for cross-platform pixel
    stability; primitives only (button, tab bar, icon set). No
    goldens for compositions — they'd churn through every tier.
  * a11y/ — contract-level gate: semantic coverage walks the
    built-in catalogue, contrast walks every token pair in every
    bundled theme against WCAG-AA thresholds (catches real
    regressions: the first run caught `tab.inactive_text` at 2.81
    in summer-night), i18n coverage asserts every referenced key
    exists in its catalog (exists-in-map, not "key == value" — too
    ambiguous for keys that happen to equal their translation).

Helpers under helpers/: `KernelFixture.create()` boots a
KernelServices with in-memory stores + a FakeDaemonClient (no
socket, drivable connected-state), `widget_harness` wraps a
widget in the minimum tree that resolves theme + i18n.

Co-Authored-By: Claude <noreply@anthropic.com>

app/test/helpers/fake_ipc.dart

@@ -0,0 +1,57 @@
+import 'package:clide/clide.dart';
+import 'package:clide_app/kernel/kernel.dart';
+
+/// A DaemonClient that doesn't actually open a socket. Use in tests
+/// that need a connected-state observable but not a real daemon.
+class FakeDaemonClient extends DaemonClient {
+  FakeDaemonClient({required super.log, required super.events})
+      : super(socketPath: '/dev/null/fake-clide.sock');
+
+  bool _fakeConnected = false;
+  final Map<String, Future<IpcResponse> Function(Map<String, Object?>)> _stubs =
+      {};
+
+  @override
+  bool get isConnected => _fakeConnected;
+
+  @override
+  Future<void> start() async {
+    // No real socket; tests drive connection-state via [setConnected].
+  }
+
+  @override
+  Future<void> stop() async {
+    _fakeConnected = false;
+    notifyListeners();
+  }
+
+  @override
+  Future<IpcResponse> request(
+    String cmd, {
+    Map<String, Object?> args = const {},
+  }) async {
+    final stub = _stubs[cmd];
+    if (stub != null) return stub(args);
+    return IpcResponse.err(
+      id: '',
+      error: IpcError(
+        code: IpcExitCode.notFound,
+        kind: IpcErrorKind.notFound,
+        message: 'no stub for $cmd',
+      ),
+    );
+  }
+
+  void setConnected(bool v) {
+    if (_fakeConnected == v) return;
+    _fakeConnected = v;
+    notifyListeners();
+  }
+
+  void stub(
+    String cmd,
+    Future<IpcResponse> Function(Map<String, Object?>) handler,
+  ) {
+    _stubs[cmd] = handler;
+  }
+}

app/test/helpers/golden_harness.dart

@@ -0,0 +1,22 @@
+import 'package:alchemist/alchemist.dart';
+
+/// Alchemist config shared across all golden tests.
+///
+/// * CI mode uses the Ahem font (shipped with Flutter's test harness) so
+///   goldens render identically on every Linux runner and developer
+///   machine. Any drift between platforms points to a real theme-token
+///   regression, not a font-rendering fluke.
+/// * Local mode keeps developer-machine fonts so you can eyeball
+///   renders naturally; the `--update-goldens` workflow still produces
+///   CI-valid goldens because CI runs the config below.
+AlchemistConfig clideGoldenConfig({bool forceCiMode = false}) {
+  return AlchemistConfig(
+    theme: null, // we're not using Material ThemeData
+    platformGoldensConfig: PlatformGoldensConfig(
+      enabled: !forceCiMode,
+    ),
+    ciGoldensConfig: const CiGoldensConfig(
+      enabled: true,
+    ),
+  );
+}

app/test/helpers/kernel_fixture.dart

@@ -0,0 +1,83 @@
+import 'dart:io';
+import 'dart:ui';
+
+import 'package:clide_app/kernel/kernel.dart';
+
+import 'fake_ipc.dart';
+
+/// Boots a [KernelServices] with in-memory defaults suitable for tests.
+/// No real daemon, no real filesystem outside a temp dir, no asset
+/// bundle — i18n catalogs are passed as literals.
+class KernelFixture {
+  KernelFixture._(
+      {required this.services, required this.ipc, required this.tempDir});
+
+  final KernelServices services;
+  final FakeDaemonClient ipc;
+  final Directory tempDir;
+
+  static Future<KernelFixture> create({
+    List<ThemeDefinition>? bundledThemes,
+    Map<String, Map<Locale, Map<String, Object?>>>? i18nCatalogs,
+    Locale? initialLocale,
+    Locale defaultLocale = const Locale('en', 'US'),
+  }) async {
+    final tempDir = await Directory.systemTemp.createTemp('clide_test_');
+    final themes = bundledThemes ?? [_miniTheme()];
+    final catalogs = i18nCatalogs ?? const {};
+    FakeDaemonClient? fake;
+    final services = await KernelServices.boot(
+      appDir: tempDir,
+      bundledThemes: themes,
+      i18nLoader: InMemoryCatalogLoader(catalogs),
+      preloadNamespaces: catalogs.keys.toList(),
+      defaultLocale: defaultLocale,
+      initialLocale: initialLocale,
+      daemonClientFactory: (log, events) {
+        fake = FakeDaemonClient(log: log, events: events);
+        return fake!;
+      },
+      autoStartDaemonClient: false,
+    );
+    return KernelFixture._(
+      services: services,
+      ipc: fake!,
+      tempDir: tempDir,
+    );
+  }
+
+  Future<void> dispose() async {
+    await services.dispose();
+    if (await tempDir.exists()) {
+      try {
+        await tempDir.delete(recursive: true);
+      } catch (_) {
+        // ignore in tests; OS will reclaim
+      }
+    }
+  }
+}
+
+/// A minimal bundled theme for tests that don't care about specific
+/// colors — just need the pipeline to resolve.
+ThemeDefinition _miniTheme() {
+  const palette = <String, Color>{
+    'primary': Color(0xFF00A3D2),
+    'accent': Color(0xFFFA5F8B),
+    'background': Color(0xFF21262F),
+    'surface': Color(0xFF393E48),
+    'panel': Color(0xFF292E38),
+    'foreground': Color(0xFFE2E8F5),
+    'muted': Color(0xFF6A7280),
+    'success': Color(0xFF00AB9A),
+    'warning': Color(0xFFD08447),
+    'error': Color(0xFFF06C6F),
+    'info': Color(0xFF00A3D2),
+  };
+  return const ThemeDefinition(
+    name: 'test',
+    displayName: 'Test',
+    dark: true,
+    palette: Palette(palette),
+  );
+}

app/test/helpers/widget_harness.dart

@@ -0,0 +1,22 @@
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter/widgets.dart';
+
+import 'kernel_fixture.dart';
+
+/// Wraps a widget in the minimum tree a primitive needs to resolve
+/// theme + i18n: `Directionality → ClideKernel → ClideTheme → child`.
+Widget harness(KernelFixture fixture, Widget child) {
+  return Directionality(
+    textDirection: TextDirection.ltr,
+    child: ClideKernel(
+      services: fixture.services,
+      child: ClideTheme(
+        controller: fixture.services.theme,
+        child: MediaQuery(
+          data: const MediaQueryData(),
+          child: child,
+        ),
+      ),
+    ),
+  );
+}