import 'dart:async'; import 'dart:io'; import 'package:flutter_test/flutter_test.dart'; import 'package:path/path.dart' as p; import 'package:code_editor/l10n/app_localizations.dart'; import 'package:code_editor/models/notice_item.dart'; import 'package:code_editor/models/run_task.dart'; import 'package:code_editor/models/run_task_type.dart'; import 'package:code_editor/providers/notice_center.dart'; import 'package:code_editor/providers/run_provider.dart'; import 'package:code_editor/services/distro_manager.dart'; import 'package:code_editor/services/project_modules/project_module.dart'; import 'package:code_editor/services/project_modules/project_probe.dart'; import 'package:code_editor/services/project_task_dispatcher.dart'; import 'package:code_editor/services/run_task_storage_service.dart'; import 'package:code_editor/widgets/notice_host.dart'; import 'package:flutter/material.dart'; /// 可控制时长的模块:用于制造"探测进行中"与"迟到的结果" class _ControllableModule extends ProjectModule { @override final String id; @override final String displayName; final List tasks; final Duration delay; _ControllableModule(this.id, this.tasks, {String? displayName, this.delay = Duration.zero}) : displayName = displayName ?? id; @override List get triggerFiles => const []; @override bool shouldActivate(Directory projectDir) => true; @override Future probe(ProjectProbe probe) async { if (delay > Duration.zero) { await Future.delayed(delay); } // 迟到的结果:模拟探测期间被取消 if (probe.isCancelled) return ModuleProbeResult.cancelled(id); return ModuleProbeResult.ok(id, tasks); } } /// 用闸门控制返回时机的模块(key = 工程目录路径),用于制造"迟到的探测结果" class _GatedModule extends ProjectModule { @override final String id; _GatedModule(this.id); final Map> _gates = {}; Completer gateFor(String projectDirPath) => _gates.putIfAbsent(projectDirPath, () => Completer()); @override String get displayName => id; @override List get triggerFiles => const []; @override bool shouldActivate(Directory projectDir) => true; @override Future probe(ProjectProbe probe) async { final gate = _gates[probe.projectDir.path]; if (gate != null && !gate.isCompleted) { await gate.future; } // 故意不检查 isCancelled:由 RunProvider 的结果守卫负责丢弃迟到结果 return ModuleProbeResult.ok(id, [ RunTask( id: 'gradle_from_${p.basename(probe.projectDir.path)}', name: 'assemble', command: 'sh ./gradlew assemble', source: TaskSource.detected, moduleId: id, ), ]); } } /// 可注入耗时与依赖状态的模块:用于验证时间预算检查点 class _BudgetModule extends ProjectModule { @override final String id; final List log; final Duration probeDelay; final Duration depsDelay; final List missingDependencies; _BudgetModule( this.id, { required this.log, this.probeDelay = Duration.zero, this.depsDelay = Duration.zero, this.missingDependencies = const [], }); @override String get displayName => id; @override List get triggerFiles => const []; @override bool shouldActivate(Directory projectDir) => true; @override Future> checkDependencies(ProjectProbe probe) async { if (depsDelay > Duration.zero) { await Future.delayed(depsDelay); } return missingDependencies; } @override Future installDependencies(ProjectProbe probe, List missing) async { log.add('$id:install'); return true; } @override Future probe(ProjectProbe probe) async { log.add('$id:probe'); if (probeDelay > Duration.zero) { await Future.delayed(probeDelay); } return ModuleProbeResult.ok(id, [ RunTask( id: '${id}_task', name: id, command: 'echo $id', source: TaskSource.detected, moduleId: id, ), ]); } } /// 固定失败的模块(用于验证失败卡片不被后续进度覆盖) class _FailingModule extends ProjectModule { @override final String id; _FailingModule(this.id); @override String get displayName => id; @override List get triggerFiles => const []; @override bool shouldActivate(Directory projectDir) => true; @override Future probe(ProjectProbe probe) async => ModuleProbeResult.failed( id, failure: NoticeFailure.executionFailed, detail: 'boom', ); } /// 触发条件依赖特征文件的模块(用于验证"空工程不激活任何模块") class _TriggeredModule extends ProjectModule { @override final String id; final List log; _TriggeredModule(this.id, {required this.log}); @override String get displayName => id; @override List get triggerFiles => const ['build.gradle']; @override bool shouldActivate(Directory projectDir) => File(p.join(projectDir.path, 'build.gradle')).existsSync(); @override Future probe(ProjectProbe probe) async { log.add('$id:probe'); return ModuleProbeResult.ok(id, const []); } } void main() { TestWidgetsFlutterBinding.ensureInitialized(); const systemName = 'test_sys'; late Directory projectA; late Directory projectB; late Directory distroBaseDir; late DistroManager distroManager; setUp(() async { projectA = await Directory.systemTemp.createTemp('probe_a_'); projectB = await Directory.systemTemp.createTemp('probe_b_'); distroBaseDir = await Directory.systemTemp.createTemp('probe_boundary_distro_'); final rootfs = Directory(p.join(distroBaseDir.path, systemName, 'rootfs')); Directory(p.join(rootfs.path, 'etc')).createSync(recursive: true); Directory(p.join(rootfs.path, 'bin')).createSync(recursive: true); distroManager = DistroManager()..customBaseDir = distroBaseDir; }); tearDown(() async { DistroManager().customBaseDir = null; for (final dir in [projectA, projectB, distroBaseDir]) { if (await dir.exists()) await dir.delete(recursive: true); } }); RunTask task(String id, String moduleId) => RunTask( id: id, name: id, command: 'echo $id', source: TaskSource.detected, moduleId: moduleId, ); group('探测系统边界', () { test('切换工程:上一个工程迟到的模块结果不得写入新工程的内存表', () async { final storage = RunTaskStorageService(); // 用闸门控制每个工程(目录)的模块返回时机 final module = _GatedModule('gradle'); final dispatcher = ProjectTaskDispatcher(customModules: [module]); final provider = RunProvider( storageService: storage, dispatcher: dispatcher, distroManager: distroManager, ); // 工程 A 的模块卡在闸门上(模拟长耗时探测) final gateA = module.gateFor(projectA.path); // 工程 B 的模块立即放行 module.gateFor(projectB.path).complete(); final probeA = provider.probeProject(projectRoot: projectA.path, systemName: systemName); await Future.delayed(const Duration(milliseconds: 30)); expect(provider.isDetecting, isTrue); // 期间切到工程 B:同一 provider 会取消 A 的探测并重新探测 final probeB = provider.probeProject(projectRoot: projectB.path, systemName: systemName); await probeB; expect(provider.currentProjectRoot, projectB.path); expect( provider.taskTable.tasksOf(RunTaskType.gradle).map((t) => t.id).toList(), ['gradle_from_${p.basename(projectB.path)}'], ); // A 的模块这时才返回(迟到结果):绝不能覆盖/污染当前工程的内存表 gateA.complete(); await probeA; expect( provider.taskTable.tasksOf(RunTaskType.gradle).map((t) => t.id).toList(), ['gradle_from_${p.basename(projectB.path)}'], reason: '被取消/被取代的探测结果必须丢弃', ); }); test('单文件任务写入 singleFile 格,且随当前打开文件本地刷新', () async { final storage = RunTaskStorageService(); final pyFile = File(p.join(projectA.path, 'main.py'))..writeAsStringSync('print(1)'); final cppFile = File(p.join(projectA.path, 'main.cpp'))..writeAsStringSync('int main(){}'); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: const []), distroManager: distroManager, ); await provider.probeProject( projectRoot: projectA.path, currentFilePath: pyFile.path, systemName: systemName, ); expect( provider.taskTable.tasksOf(RunTaskType.singleFile).map((t) => t.id), ['detected_single_python'], ); // 切换打开的文件 -> 本地重算(不跑容器) provider.refreshSingleFileTask(currentFilePath: cppFile.path); expect( provider.taskTable.tasksOf(RunTaskType.singleFile).map((t) => t.id), ['detected_single_cpp'], ); // 切到无对应运行方式的文件 -> 该格清空 final txtFile = File(p.join(projectA.path, 'notes.txt'))..writeAsStringSync('hi'); provider.refreshSingleFileTask(currentFilePath: txtFile.path); expect(provider.taskTable.tasksOf(RunTaskType.singleFile), isEmpty); }); test('未映射到内置类型的自定义模块:任务归入 other,不能丢', () async { final storage = RunTaskStorageService(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: [ _ControllableModule('maven', [task('maven_package', 'maven')]), ]), distroManager: distroManager, ); await provider.probeProject(projectRoot: projectA.path, systemName: systemName); expect(provider.taskTable.tasksOf(RunTaskType.other).map((t) => t.id), ['maven_package']); expect(provider.detectedTasks.any((t) => t.id == 'maven_package'), isTrue); expect(RunTaskType.ofTask(task('maven_package', 'maven')), RunTaskType.other); }); test('探测进行中被 dispose:取消会话且不再抛"释放后通知"异常', () async { final storage = RunTaskStorageService(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: [ _ControllableModule('gradle', [task('gradle_x', 'gradle')], delay: const Duration(milliseconds: 80)), ]), distroManager: distroManager, ); final running = provider.probeProject(projectRoot: projectA.path, systemName: systemName); await Future.delayed(const Duration(milliseconds: 20)); provider.dispose(); // 不抛异常(ChangeNotifier 释放后调用 notifyListeners 会抛) await running; expect(provider.isDetecting, isFalse); }); test('空项目(无任何构建特征文件):不启动模块探测,但用户探测与单文件任务照常', () async { // 空工程:不放任何构建文件,只放一个可运行的源文件 final pyFile = File(p.join(projectA.path, 'main.py'))..writeAsStringSync('print(1)'); final storage = RunTaskStorageService(); await storage.saveConfig(projectRoot: projectA.path, tasks: [ const RunTask(id: 'user_1', name: 'u', command: 'echo', source: TaskSource.custom), ]); final log = []; final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: [ // 触发条件为"必须有 build.gradle"的模块:空工程下不应被激活 _TriggeredModule('gradle', log: log), ]), distroManager: distroManager, ); await provider.probeProject( projectRoot: projectA.path, currentFilePath: pyFile.path, systemName: systemName, ); // 没有模块被激活 -> 一次探测都没跑 expect(log, isEmpty); expect(provider.lastProbeReport?.totalModules, 0); expect(provider.detectedTasks.where((t) => t.moduleId != null), isEmpty); // 用户任务照常(来自磁盘) expect(provider.customTasks.map((t) => t.id), ['user_1']); // 单文件任务照常(本地计算,不依赖任何模块) expect(provider.taskTable.tasksOf(RunTaskType.singleFile).map((t) => t.id), ['detected_single_python']); }); test('工程外的文件不产出单文件任务(容器内不存在该文件)', () async { final outsideDir = await Directory.systemTemp.createTemp('probe_outside_'); addTearDown(() async { if (await outsideDir.exists()) await outsideDir.delete(recursive: true); }); final outsidePy = File(p.join(outsideDir.path, 'main.py'))..writeAsStringSync('print(1)'); final storage = RunTaskStorageService(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: const []), distroManager: distroManager, ); await provider.probeProject( projectRoot: projectA.path, currentFilePath: outsidePy.path, systemName: systemName, ); expect(provider.taskTable.tasksOf(RunTaskType.singleFile), isEmpty); expect(ProjectTaskDispatcher.detectSingleFileTask(projectA.path, outsidePy.path), isNull); }); test('关闭工程:清空内存并终止进行中的探测', () async { final storage = RunTaskStorageService(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: [ _ControllableModule('gradle', [task('gradle_x', 'gradle')], delay: const Duration(milliseconds: 60)), ]), distroManager: distroManager, ); final running = provider.probeProject(projectRoot: projectA.path, systemName: systemName); await Future.delayed(const Duration(milliseconds: 10)); expect(provider.isDetecting, isTrue); provider.onProjectClosed(); expect(provider.currentProjectRoot, isNull); expect(provider.taskTable.isEmpty, isTrue); await running; expect(provider.taskTable.isEmpty, isTrue, reason: '关闭工程后迟到的结果不得回填'); }); }); group('用户任务与"上一次执行任务"的加载边界', () { test('进入项目必定加载用户任务;无可用系统时也照常加载', () async { final storage = RunTaskStorageService(); await storage.saveConfig(projectRoot: projectA.path, tasks: [ const RunTask(id: 'user_a', name: 'a', command: 'echo a', source: TaskSource.custom), const RunTask(id: 'user_b', name: 'b', command: 'echo b', source: TaskSource.custom), ], lastRunTaskId: 'user_b'); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: const []), distroManager: distroManager, ); // 没有可用系统(systemName = null):系统探测会跳过,但用户任务必须加载 await provider.probeProject(projectRoot: projectA.path, systemName: null); expect(provider.customTasks.map((t) => t.id), ['user_a', 'user_b']); expect(provider.lastRunTask?.id, 'user_b'); }); test('未进入项目时用户探测是空操作(没有工程根就不加载)', () async { final storage = RunTaskStorageService(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: const []), distroManager: distroManager, ); await provider.probeUser(); expect(provider.customTasks, isEmpty); expect(provider.currentProjectRoot, isNull); }); test('run_tasks.json 损坏:加载为空但不抛异常(磁盘文件保持原样)', () async { final storage = RunTaskStorageService(); final configFile = storage.getConfigFile(projectA.path); configFile.parent.createSync(recursive: true); configFile.writeAsStringSync('{ this is not json ]'); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: const []), distroManager: distroManager, ); await provider.probeProject(projectRoot: projectA.path, systemName: null); expect(provider.customTasks, isEmpty); // 坏文件不被覆盖(用户仍可手工修复) expect(configFile.existsSync(), isTrue); expect(configFile.readAsStringSync(), contains('not json')); }); test('刚打开工程就记录"上次执行任务":不得清空磁盘上已有的用户任务', () async { final storage = RunTaskStorageService(); await storage.saveConfig(projectRoot: projectA.path, tasks: [ const RunTask(id: 'user_a', name: 'a', command: 'echo a', source: TaskSource.custom), const RunTask(id: 'user_b', name: 'b', command: 'echo b', source: TaskSource.custom), ]); // 全新 provider:内存里还没有任何用户任务 final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: const []), distroManager: distroManager, ); provider.onProjectOpened(projectA.path, systemName: null); // 不等待加载 await provider.setLastRunTask( const RunTask(id: 'user_a', name: 'a', command: 'echo a', source: TaskSource.custom), ); // 磁盘上两个任务都必须还在,只是 lastRunTaskId 被更新 final persisted = await storage.loadConfig(projectA.path); expect(persisted.tasks.map((t) => t.id), containsAll(['user_a', 'user_b'])); expect(persisted.lastRunTaskId, 'user_a'); }); test('内存尚未加载完时添加用户任务:以磁盘为基准,不丢已有任务', () async { final storage = RunTaskStorageService(); await storage.saveConfig(projectRoot: projectA.path, tasks: [ const RunTask(id: 'user_a', name: 'a', command: 'echo a', source: TaskSource.custom), ]); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: const []), distroManager: distroManager, ); // 只绑定工程根,不等用户探测完成 provider.onProjectOpened(projectA.path, systemName: null); await provider.addCustomTask( const RunTask(id: 'user_new', name: 'n', command: 'echo n', source: TaskSource.custom), ); final persisted = await storage.loadConfig(projectA.path); expect(persisted.tasks.map((t) => t.id), containsAll(['user_a', 'user_new'])); }); }); group('通知文案顺序(Gradle 为例)', () { test('失败卡片不会被后续队列进度覆盖(失败原因保留、不再二次确认)', () async { final center = NoticeCenter(); final storage = RunTaskStorageService(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: [ // gradle 立刻失败,npm 稍慢 -> 期间会持续上报队列进度 _FailingModule('gradle'), _BudgetModule('npm', log: [], probeDelay: const Duration(milliseconds: 60)), ]), distroManager: distroManager, noticeCenter: center, ); await provider.probeProject(projectRoot: projectA.path, systemName: systemName); final gradleNotice = center.visible.firstWhere((n) => n.id == 'probe:gradle'); expect(gradleNotice.kind, NoticeKind.failure); final text = gradleNotice.text as ModuleFailureText; expect(text.moduleDisplayName, 'gradle'); expect(text.failure, NoticeFailure.executionFailed); expect(gradleNotice.confirmBeforeDismiss, isFalse, reason: '模块已结束,关闭失败卡片不再是破坏性操作'); }); test('成功卡片不会被后续队列进度回写为"排队等待中"', () async { final center = NoticeCenter(); final storage = RunTaskStorageService(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: [ _BudgetModule('gradle', log: []), _BudgetModule('npm', log: [], probeDelay: const Duration(milliseconds: 80)), ]), distroManager: distroManager, noticeCenter: center, ); // 不 await:在 npm 还在跑的时候检查 gradle 的卡片 final running = provider.probeProject(projectRoot: projectA.path, systemName: systemName); await Future.delayed(const Duration(milliseconds: 60)); final gradleNotice = center.visible.firstWhere((n) => n.id == 'probe:gradle'); expect(gradleNotice.kind, NoticeKind.success); expect(gradleNotice.text, isA()); await running; }); }); group('探测时间预算', () { test('模块之间超预算:剩余模块标记 skippedByBudget,且不再执行探测', () async { final log = []; final dispatcher = ProjectTaskDispatcher(customModules: [ _BudgetModule('gradle', log: log, probeDelay: const Duration(milliseconds: 40)), _BudgetModule('npm', log: log), _BudgetModule('make', log: log), ]); final probe = dispatcher.createProbe( projectRoot: projectA.path, systemName: systemName, distroManager: distroManager, budget: const Duration(milliseconds: 15), ); final report = await dispatcher.run(probe); probe.dispose(); expect(report.abortedByBudget, isTrue); expect(report.totalModules, 3); expect(report.completedModules, 1); expect(report.moduleResults['gradle']!.status, ModuleProbeStatus.ok); expect(report.moduleResults['npm']!.status, ModuleProbeStatus.skippedByBudget); expect(report.moduleResults['make']!.status, ModuleProbeStatus.skippedByBudget); // 后两个模块连探测都没开始 expect(log, ['gradle:probe']); }); test('预算充足:正常跑完全部模块', () async { final log = []; final dispatcher = ProjectTaskDispatcher(customModules: [ _BudgetModule('gradle', log: log), _BudgetModule('npm', log: log), ]); final probe = dispatcher.createProbe( projectRoot: projectA.path, systemName: systemName, distroManager: distroManager, budget: const Duration(seconds: 30), ); final report = await dispatcher.run(probe); probe.dispose(); expect(report.abortedByBudget, isFalse); expect(report.completedModules, 2); expect(log, ['gradle:probe', 'npm:probe']); }); test('依赖安装前超预算:跳过安装(避免半装状态),模块标记 skippedByBudget', () async { final log = []; final dispatcher = ProjectTaskDispatcher(customModules: [ _BudgetModule( 'gradle', log: log, depsDelay: const Duration(milliseconds: 40), missingDependencies: const ['gradle'], ), ]); final probe = dispatcher.createProbe( projectRoot: projectA.path, systemName: systemName, distroManager: distroManager, budget: const Duration(milliseconds: 15), ); final report = await dispatcher.run(probe); probe.dispose(); expect(report.abortedByBudget, isTrue); expect(report.moduleResults['gradle']!.status, ModuleProbeStatus.skippedByBudget); expect(log.contains('gradle:install'), isFalse, reason: '预算将尽时不得开跑可能长达 10 分钟的安装'); expect(log.contains('gradle:probe'), isFalse); }); test('RunProvider:预算中止后弹出可关闭的"已中止"通知(× 仍可用)', () async { final storage = RunTaskStorageService(); final center = NoticeCenter(); final provider = RunProvider( storageService: storage, dispatcher: ProjectTaskDispatcher(customModules: [ _BudgetModule('gradle', log: [], probeDelay: const Duration(milliseconds: 40)), _BudgetModule('npm', log: []), ]), distroManager: distroManager, noticeCenter: center, probeBudget: const Duration(milliseconds: 15), ); await provider.probeProject(projectRoot: projectA.path, systemName: systemName); final budgetNotice = center.visible.firstWhere((n) => n.id == 'probe:budget'); expect(budgetNotice.sticky, isTrue); expect(budgetNotice.text, isA()); final text = budgetNotice.text as ProbeBudgetExceededText; expect(text.completed, 1); expect(text.total, 2); // × 仍然可以关闭它(保留 x) center.dismiss('probe:budget'); center.finalizeDismiss('probe:budget'); expect(center.visible.any((n) => n.id == 'probe:budget'), isFalse); }); }); group('通知 × 的附加动作', () { testWidgets('点击进行中通知的 × 会触发 onUserDismiss(用于取消探测)', (tester) async { final center = NoticeCenter(); var cancelled = false; await tester.pumpWidget( MaterialApp( locale: const Locale('zh'), localizationsDelegates: AppLocalizations.localizationsDelegates, supportedLocales: AppLocalizations.supportedLocales, home: Scaffold( body: Stack(children: [ Positioned.fill(child: NoticeHost(center: center)), ]), ), ), ); await tester.pumpAndSettle(); center.push(NoticeItem( id: 'probe:gradle', kind: NoticeKind.progress, text: const ModulePhaseText( moduleDisplayName: 'Gradle', phase: ProbeNoticePhase.detecting, ), onUserDismiss: () => cancelled = true, )); await tester.pump(); await tester.pump(const Duration(milliseconds: 300)); await tester.tap(find.byIcon(Icons.close)); await tester.pump(); expect(cancelled, isTrue, reason: '× 应触发附加动作'); await tester.pump(const Duration(milliseconds: 400)); expect(center.visible, isEmpty); }); }); }