Files
LN-Code-Editor/test/probe_boundary_test.dart
2026-09-17 16:32:27 +08:00

742 lines
27 KiB
Dart
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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<RunTask> tasks;
final Duration delay;
_ControllableModule(this.id, this.tasks, {String? displayName, this.delay = Duration.zero})
: displayName = displayName ?? id;
@override
List<String> get triggerFiles => const [];
@override
bool shouldActivate(Directory projectDir) => true;
@override
Future<ModuleProbeResult> probe(ProjectProbe probe) async {
if (delay > Duration.zero) {
await Future<void>.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<String, Completer<void>> _gates = {};
Completer<void> gateFor(String projectDirPath) =>
_gates.putIfAbsent(projectDirPath, () => Completer<void>());
@override
String get displayName => id;
@override
List<String> get triggerFiles => const [];
@override
bool shouldActivate(Directory projectDir) => true;
@override
Future<ModuleProbeResult> 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<String> log;
final Duration probeDelay;
final Duration depsDelay;
final List<String> 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<String> get triggerFiles => const [];
@override
bool shouldActivate(Directory projectDir) => true;
@override
Future<List<String>> checkDependencies(ProjectProbe probe) async {
if (depsDelay > Duration.zero) {
await Future<void>.delayed(depsDelay);
}
return missingDependencies;
}
@override
Future<bool> installDependencies(ProjectProbe probe, List<String> missing) async {
log.add('$id:install');
return true;
}
@override
Future<ModuleProbeResult> probe(ProjectProbe probe) async {
log.add('$id:probe');
if (probeDelay > Duration.zero) {
await Future<void>.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<String> get triggerFiles => const [];
@override
bool shouldActivate(Directory projectDir) => true;
@override
Future<ModuleProbeResult> probe(ProjectProbe probe) async => ModuleProbeResult.failed(
id,
failure: NoticeFailure.executionFailed,
detail: 'boom',
);
}
/// 触发条件依赖特征文件的模块(用于验证"空工程不激活任何模块")
class _TriggeredModule extends ProjectModule {
@override
final String id;
final List<String> log;
_TriggeredModule(this.id, {required this.log});
@override
String get displayName => id;
@override
List<String> get triggerFiles => const ['build.gradle'];
@override
bool shouldActivate(Directory projectDir) =>
File(p.join(projectDir.path, 'build.gradle')).existsSync();
@override
Future<ModuleProbeResult> 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<void>.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);
// 上一次运行单文件任务时的联动测试:
// 1. 在 cpp 文件设置单文件任务为 lastRunTask
provider.refreshSingleFileTask(currentFilePath: cppFile.path);
final cppTask = provider.taskTable.tasksOf(RunTaskType.singleFile).first;
await provider.setLastRunTask(cppTask);
expect(provider.lastRunTask?.id, 'detected_single_cpp');
// 2. 切换到 python 文件 -> lastRunTask 自动联动为当前 py 文件的任务
provider.refreshSingleFileTask(currentFilePath: pyFile.path);
expect(provider.lastRunTask?.id, 'detected_single_python');
expect(provider.lastRunTask?.name, 'Python: main.py');
// 3. 切换到不可运行文件(txt)-> lastRunTask 安全置空,不误跑切走的文件
provider.refreshSingleFileTask(currentFilePath: txtFile.path);
expect(provider.lastRunTask, isNull);
// 4. 再切回 cpp 文件 -> 重新恢复为 cpp 单文件任务
provider.refreshSingleFileTask(currentFilePath: cppFile.path);
expect(provider.lastRunTask?.id, 'detected_single_cpp');
});
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<void>.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 = <String>[];
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<void>.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<void>.delayed(const Duration(milliseconds: 60));
final gradleNotice = center.visible.firstWhere((n) => n.id == 'probe:gradle');
expect(gradleNotice.kind, NoticeKind.success);
expect(gradleNotice.text, isA<ModuleDoneText>());
await running;
});
});
group('探测时间预算', () {
test('模块之间超预算:剩余模块标记 skippedByBudget,且不再执行探测', () async {
final log = <String>[];
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 = <String>[];
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 = <String>[];
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<ProbeBudgetExceededText>());
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);
});
});
}