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/a11y/contrast_test.dart

@@ -0,0 +1,37 @@
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter/services.dart' show rootBundle;
+import 'package:flutter_test/flutter_test.dart';
+
+/// WCAG-AA contrast gate. Every bundled theme's token pairs (listed in
+/// [canonicalPairs]) must clear 4.5:1 for normal text / 3:1 for large
+/// text. Failing pairs are printed with their computed ratio so a
+/// theme-token regression shows exactly which pair broke.
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  group('contrast — all bundled themes meet WCAG AA', () {
+    const bundledPaths = [
+      'lib/kernel/src/theme/themes/summer-night.yaml',
+    ];
+
+    for (final path in bundledPaths) {
+      test('theme: $path', () async {
+        final def = await const ThemeLoader().fromAsset(rootBundle, path);
+        const resolver = ThemeResolver();
+        final tokens = resolver.resolve(
+          palette: def.palette,
+          semanticOverride: def.semanticOverride,
+          surfaceOverride: def.surfaceOverride,
+          extensionOverride: def.extensionOverride,
+        );
+        final failures = failingPairs(tokens);
+        if (failures.isNotEmpty) {
+          fail(
+            'Contrast failures in ${def.name}:\n'
+            '${failures.map((f) => '  - $f').join('\n')}',
+          );
+        }
+      });
+    }
+  });
+}

app/test/a11y/i18n_coverage_test.dart

@@ -0,0 +1,65 @@
+import 'dart:ui';
+
+import 'package:clide_app/kernel/kernel.dart';
+import 'package:flutter/services.dart' show rootBundle;
+import 'package:flutter_test/flutter_test.dart';
+
+/// Asserts every bundled i18n catalog is well-formed and every key the
+/// Tier-0 built-ins ask for actually resolves.
+///
+/// The second check is important: in a text-driven i18n system missing
+/// keys show the placeholder, so a runtime lookup test wouldn't "fail"
+/// on a typo — we have to assert the keys exist up front.
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  /// (namespace, key) pairs referenced by Tier-0 built-ins. Extend when
+  /// new keys land.
+  const referenced = <String, List<String>>{
+    'builtin.welcome': [
+      'title',
+      'subtitle',
+      'open-project',
+      'open-project.hint',
+      'tab.title',
+    ],
+    'builtin.ipc-status': [
+      'connected',
+      'connected.hint',
+      'disconnected',
+      'disconnected.hint',
+    ],
+    'builtin.theme-picker': [
+      'modal.title',
+      'modal.cancel',
+      'modal.cancel.hint',
+      'row.select.hint',
+    ],
+    'builtin.default-layout': [
+      'command.reset',
+      'preset.classic',
+    ],
+  };
+
+  group('i18n coverage (Tier 0)', () {
+    for (final entry in referenced.entries) {
+      final ns = entry.key;
+      test('$ns catalog contains every referenced key', () async {
+        final loader = AssetCatalogLoader(bundle: rootBundle);
+        final catalog = await loader.load(ns, const Locale('en', 'US'));
+        expect(
+          catalog,
+          isNotEmpty,
+          reason: 'catalog for "$ns" failed to load (asset path wrong?)',
+        );
+        for (final key in entry.value) {
+          expect(
+            catalog.containsKey(key),
+            isTrue,
+            reason: 'namespace "$ns" catalog is missing key "$key"',
+          );
+        }
+      });
+    }
+  });
+}

app/test/a11y/keyboard_traversal_test.dart

@@ -0,0 +1,48 @@
+import 'package:clide_app/widgets/widgets.dart';
+import 'package:flutter/semantics.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../helpers/kernel_fixture.dart';
+import '../helpers/widget_harness.dart';
+
+/// Tier-0 smoke — each interactive primitive can *hold* focus when a
+/// [Focus] wraps it, and Semantics reports the right tap action. Full
+/// Tab-traversal order lives in `integration_test/app_starts_test.dart`
+/// where the real WidgetsApp + DefaultFocusTraversal are present.
+void main() {
+  group('keyboard focusability', () {
+    late KernelFixture f;
+    setUp(() async => f = await KernelFixture.create());
+    tearDown(() async => f.dispose());
+
+    testWidgets('ClideButton can be programmatically focused', (tester) async {
+      final node = FocusNode();
+      addTearDown(node.dispose);
+      await tester.pumpWidget(
+        harness(
+          f,
+          Focus(
+            focusNode: node,
+            child: ClideButton(label: 'Save', onPressed: () {}),
+          ),
+        ),
+      );
+      node.requestFocus();
+      await tester.pump();
+      expect(node.hasFocus, isTrue);
+    });
+
+    testWidgets('interactive widgets expose tap actions to a11y',
+        (tester) async {
+      await tester.pumpWidget(
+        harness(f, ClideButton(label: 'Save', onPressed: () {})),
+      );
+      final handle = tester.ensureSemantics();
+      final data =
+          tester.getSemantics(find.byType(ClideButton)).getSemanticsData();
+      expect(data.hasAction(SemanticsAction.tap), isTrue);
+      handle.dispose();
+    });
+  });
+}

app/test/a11y/semantic_coverage_test.dart

@@ -0,0 +1,66 @@
+import 'package:clide_app/builtin/default_layout/default_layout.dart';
+import 'package:clide_app/builtin/ipc_status/ipc_status.dart';
+import 'package:clide_app/builtin/theme_picker/theme_picker.dart';
+import 'package:clide_app/builtin/welcome/welcome.dart';
+import 'package:clide_app/extension/extension.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+/// Cross-extension contract check: every built-in extension declares a
+/// non-empty title + version (so screen readers and the extensions-ui
+/// surface can announce them) and every interactive contribution
+/// carries enough data to build a Semantics node.
+///
+/// Per-widget Semantics-label checks live in each built-in's own
+/// widget_test.dart (`test/builtin/**/widget_test.dart`) — they run
+/// against a real pumped tree and assert the exact `label` + `hint`
+/// reach the user. This file is the "nothing is missing from the
+/// catalog" gate.
+void main() {
+  group('Tier-0 built-in extensions — contract-level coverage', () {
+    final extensions = <ClideExtension>[
+      DefaultLayoutExtension(),
+      WelcomeExtension(),
+      IpcStatusExtension(),
+      ThemePickerExtension(),
+    ];
+
+    for (final ext in extensions) {
+      group(ext.id, () {
+        test('has non-empty title + version', () {
+          expect(ext.title, isNotEmpty);
+          expect(ext.version, isNotEmpty);
+        });
+
+        test('tab contributions carry title + i18n key + namespace', () {
+          final tabs = ext.contributions.whereType<TabContribution>().toList();
+          for (final t in tabs) {
+            expect(t.title, isNotEmpty,
+                reason: '${ext.id} tab ${t.id} missing English title');
+            if (t.titleKey != null) {
+              expect(t.i18nNamespace, isNotNull,
+                  reason:
+                      '${ext.id} tab ${t.id} has titleKey but no namespace');
+            }
+          }
+        });
+
+        test('command contributions carry stable ids', () {
+          final cmds =
+              ext.contributions.whereType<CommandContribution>().toList();
+          for (final c in cmds) {
+            expect(c.command, isNotEmpty);
+            expect(c.id, isNotEmpty);
+          }
+        });
+      });
+    }
+
+    test('every registered tab hits a real slot', () {
+      for (final ext in extensions) {
+        for (final t in ext.contributions.whereType<TabContribution>()) {
+          expect(t.slot.value, isNotEmpty);
+        }
+      }
+    });
+  });
+}