This commit is contained in:
LZX committed 2026-09-16 20:43:39 +08:00
1 parent 5efc778165
commit 59125d185c
64 files changed
+7912 -1393

No files matched your search

+68
View File
@@ -558,5 +558,73 @@ void main() {
controller.hide(buildCtx);
await tester.pumpAndSettle();
});
testWidgets('选中文本后进行滚动,手柄层不应被销毁消失且在滚动停止后正常维持', (tester) async {
final codeController = CodeLineEditingController.fromText(
List.generate(50, (i) => 'Line $i: Content of the test line with some length').join('\n'),
);
final scrollController = CodeScrollController();
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SizedBox(
width: 400,
height: 300,
child: CodeEditor(
controller: codeController,
scrollController: scrollController,
wordWrap: false,
),
),
),
),
);
await tester.pumpAndSettle();
// 选中第 5 行文本
codeController.selection = const CodeLineSelection(
baseIndex: 5,
baseOffset: 0,
extentIndex: 5,
extentOffset: 10,
);
await tester.pumpAndSettle();
// 执行纵向滚动
await tester.drag(find.byType(CodeEditor), const Offset(0, -60));
await tester.pumpAndSettle();
// 选区依然存在
expect(codeController.selection.isCollapsed, isFalse);
});
testWidgets('非折行模式(wordWrap: false)下控制器替换文本,渲染段落立即更新', (tester) async {
final codeController = CodeLineEditingController.fromText('initial_text');
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SizedBox(
width: 400,
height: 300,
child: CodeEditor(
controller: codeController,
wordWrap: false,
),
),
),
),
);
await tester.pumpAndSettle();
// 模拟小键盘输入:修改文本
codeController.replaceSelection('appended');
await tester.pumpAndSettle();
// 验证文字已在控制器中
expect(codeController.text, contains('appended'));
// 验证未抛异常且稳定渲染
expect(find.byType(CodeEditor), findsOneWidget);
});
});
}
@@ -0,0 +1,115 @@
// 回归测试:非折行模式(wordWrap == false)下,文本改动必须立即重排“显示段落”。
//
// 背景:为缓解“双指缩放/横向滚动抖动”,`_CodeFieldRender._updateDisplayRenderParagraphs()`
// 里曾为非折行模式加过一个 startIndex 复用缓存分支:仅当 startIndex 变化或视口跑出已建段落
// 范围时才 clear()+重建。于是“按键已生效(控制器内容变了、脏标记也正确)但屏幕仍绘制旧段落”,
// 表现为小键盘按键像失灵、文字不动却变脏。
// 抖动真因(行高 StrutStyle forceStrutHeight 约束缺失)修复后,该缓存分支已删除,本文件守住行为。
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:re_editor/re_editor.dart';
/// 从渲染树中取出真正用于绘制的显示段落(`_CodeFieldRender` 为库内私有类型,按类型名匹配)
List<CodeLineRenderParagraph> displayParagraphs(WidgetTester tester) {
final render = tester.allRenderObjects.firstWhere(
(object) => object.runtimeType.toString() == '_CodeFieldRender',
orElse: () => throw StateError('渲染树中找不到 _CodeFieldRender'),
);
final dynamic field = render;
return (field.displayParagraphs as List).cast<CodeLineRenderParagraph>();
}
/// 取指定行号对应的显示段落
CodeLineRenderParagraph paragraphOfLine(WidgetTester tester, int lineIndex) {
return displayParagraphs(tester).firstWhere(
(paragraph) => paragraph.index == lineIndex,
orElse: () => throw StateError('显示段落中找不到第 $lineIndex 行'),
);
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('非折行模式下文本改动立即重排显示段落', () {
const firstLineText = 'Line 0: const value = 0;';
Future<CodeLineEditingController> pumpEditor(WidgetTester tester) async {
// 文档行数足够填满视口:已建段落覆盖整个可视区,正是“复用缓存”生效的前提
final text = List.generate(60, (i) => 'Line $i: const value = $i;').join('\n');
final controller = CodeLineEditingController.fromText(text);
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SizedBox(
width: 300,
height: 300,
child: CodeEditor(
controller: controller,
wordWrap: false,
// paddingTop 必须为 0(应用侧同样是 fromLTRB(6,0,0,0)):
// paddingTop > 0 时 `target < _displayParagraphs.first.top` 恒成立,
// 会让缓存分支每次都重建,从而掩盖本缺陷。
padding: EdgeInsets.zero,
),
),
),
),
);
await tester.pumpAndSettle();
// 光标固定到首行行首,确保改动落在可见行上
controller.selection = CodeLineSelection.collapsed(index: 0, offset: 0);
await tester.pumpAndSettle();
return controller;
}
testWidgets('小键盘输入单个字符 ";" 后显示段落立即刷新(不依赖滚动)', (tester) async {
final controller = await pumpEditor(tester);
expect(paragraphOfLine(tester, 0).length, firstLineText.length);
// 等价于小键盘 / 硬件键盘按键:只改控制器内容,屏幕不滚动
controller.replaceSelection(';');
await tester.pumpAndSettle();
final expectedLength = controller.text.split('\n').first.length;
expect(expectedLength, firstLineText.length + 1, reason: '按键必须真正写入控制器');
expect(
paragraphOfLine(tester, 0).length,
expectedLength,
reason: '屏幕显示段落必须与控制器同步刷新',
);
});
testWidgets('小键盘输入组合字符 "()" 后显示段落立即刷新', (tester) async {
final controller = await pumpEditor(tester);
controller.replaceSelection('()');
await tester.pumpAndSettle();
final expectedLength = controller.text.split('\n').first.length;
expect(expectedLength, firstLineText.length + 2);
expect(paragraphOfLine(tester, 0).length, expectedLength);
});
testWidgets('插入换行后显示段落立即拆分,后续行整体下移', (tester) async {
final controller = await pumpEditor(tester);
expect(paragraphOfLine(tester, 0).length, firstLineText.length);
expect(paragraphOfLine(tester, 1).length, 'Line 1: const value = 1;'.length);
controller.replaceSelection('\n');
await tester.pumpAndSettle();
expect(controller.text.split('\n').length, 61);
// 原首行被拆成“空行 + 原内容”,屏幕段落必须同步反映
expect(paragraphOfLine(tester, 0).length, 0, reason: '首段应变为空行');
expect(
paragraphOfLine(tester, 1).length,
firstLineText.length,
reason: '原来的首行内容必须出现在第 2 段(屏幕未重排时会残留旧文本)',
);
});
});
}
+27
View File
@@ -86,6 +86,33 @@ void main() {
expect(await manager.hasAnySystem(), isFalse);
});
test('空壳 rootfs(只有 etc 缺少 bin)不被视为已安装系统,也不会出现在列表里', () async {
// 复现历史缺陷遗留物:探测流程的 ensure* 会在未安装的系统名下造出 rootfs/etc
final ghostEtc = Directory(p.join(tempBaseDir.path, 'ghost', 'rootfs', 'etc'));
ghostEtc.createSync(recursive: true);
File(p.join(ghostEtc.path, 'resolv.conf')).writeAsStringSync('nameserver 1.1.1.1\n');
// 一个真正可用的系统实例
final realRootfs = Directory(p.join(tempBaseDir.path, 'real', 'rootfs'));
Directory(p.join(realRootfs.path, 'etc')).createSync(recursive: true);
Directory(p.join(realRootfs.path, 'bin')).createSync(recursive: true);
expect(await manager.listInstalledSystems(), equals(<String>['real']));
expect(await manager.isSystemInstalled('ghost'), isFalse);
expect(await manager.isSystemInstalled('real'), isTrue);
});
test('buildLaunchConfig 对未安装的系统直接抛错,且不在磁盘上创建任何目录', () async {
await expectLater(
manager.buildLaunchConfig(
systemName: 'not_installed',
workspacePath: tempBaseDir.path,
),
throwsA(isA<StateError>()),
);
expect(Directory(p.join(tempBaseDir.path, 'not_installed')).existsSync(), isFalse);
});
test('同一 Rootfs 包支持导入并创建多个独立系统实例', () async {
final gzBytes = createMockRootfsTarGz();
final tempGzFile = File(p.join(tempBaseDir.path, 'source_rootfs.tar.gz'));
+257
View File
@@ -0,0 +1,257 @@
import 'dart:io';
import 'dart:typed_data';
import 'package:code_editor/l10n/app_localizations.dart';
import 'package:code_editor/models/project_history.dart';
import 'package:code_editor/providers/project_provider.dart';
import 'package:code_editor/providers/run_provider.dart';
import 'package:code_editor/providers/settings_provider.dart';
import 'package:code_editor/providers/tab_provider.dart';
import 'package:code_editor/services/internal_project_service.dart';
import 'package:code_editor/widgets/code_editor_drawer.dart';
import 'package:file_picker/file_picker.dart';
import 'package:flutter/material.dart';
import 'package:flutter_localizations/flutter_localizations.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:path/path.dart' as p;
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
class MockMultiFilePicker extends FilePicker {
List<PlatformFile>? pickedFiles;
@override
Future<FilePickerResult?> pickFiles({
String? dialogTitle,
String? initialDirectory,
FileType type = FileType.any,
List<String>? allowedExtensions,
Function(FilePickerStatus)? onFileLoading,
bool allowCompression = false,
int compressionQuality = 30,
bool allowMultiple = false,
bool withData = false,
bool withReadStream = false,
bool lockParentWindow = false,
bool readSequential = false,
}) async {
if (pickedFiles == null) return null;
return FilePickerResult(pickedFiles!);
}
@override
Future<bool?> clearTemporaryFiles() async => true;
@override
Future<String?> getDirectoryPath({
String? dialogTitle,
bool lockParentWindow = false,
String? initialDirectory,
}) async => null;
@override
Future<String?> saveFile({
String? dialogTitle,
String? fileName,
String? initialDirectory,
FileType type = FileType.any,
List<String>? allowedExtensions,
Uint8List? bytes,
bool lockParentWindow = false,
}) async => null;
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
late Directory tempBaseDir;
late Directory testProjectDir;
late ProjectProvider projectProvider;
late TabProvider tabProvider;
late SettingsProvider settingsProvider;
late RunProvider runProvider;
late MockMultiFilePicker mockFilePicker;
setUp(() async {
SharedPreferences.setMockInitialValues({});
tempBaseDir = Directory.systemTemp.createTempSync('drawer_import_test_');
testProjectDir = Directory(p.join(tempBaseDir.path, 'my_project'))..createSync();
InternalProjectService.instance.customProjectsDir =
Directory(p.join(tempBaseDir.path, 'files', 'projects'));
projectProvider = ProjectProvider();
tabProvider = TabProvider()..bindProjectProvider(projectProvider);
settingsProvider = SettingsProvider();
runProvider = RunProvider();
mockFilePicker = MockMultiFilePicker();
FilePicker.platform = mockFilePicker;
// Switch to active project
await projectProvider.switchProject(
ProjectHistory(
rootPath: testProjectDir.path,
lastOpenedFilePath: null,
),
);
});
tearDown(() {
InternalProjectService.instance.customProjectsDir = null;
if (tempBaseDir.existsSync()) {
tempBaseDir.deleteSync(recursive: true);
}
});
Widget buildTestWidget({
Locale locale = const Locale('zh'),
}) {
return MultiProvider(
providers: [
ChangeNotifierProvider<ProjectProvider>.value(value: projectProvider),
ChangeNotifierProvider<TabProvider>.value(value: tabProvider),
ChangeNotifierProvider<SettingsProvider>.value(value: settingsProvider),
ChangeNotifierProvider<RunProvider>.value(value: runProvider),
],
child: MaterialApp(
localizationsDelegates: const [
AppLocalizations.delegate,
GlobalMaterialLocalizations.delegate,
GlobalWidgetsLocalizations.delegate,
GlobalCupertinoLocalizations.delegate,
],
supportedLocales: const [
Locale('zh'),
Locale('en'),
],
locale: locale,
home: const Scaffold(
drawer: CodeEditorDrawer(),
body: Center(child: Text('Editor Body')),
),
),
);
}
testWidgets('Import button is present to the right of new file and new folder buttons with correct tooltip', (tester) async {
await tester.pumpWidget(buildTestWidget(locale: const Locale('zh')));
final scaffoldState = tester.state<ScaffoldState>(find.byType(Scaffold));
scaffoldState.openDrawer();
await tester.pumpAndSettle();
// Verify buttons in the subtitle row
expect(find.byIcon(Icons.note_add_outlined), findsOneWidget);
expect(find.byIcon(Icons.create_new_folder_outlined), findsOneWidget);
expect(find.byIcon(Icons.file_upload_outlined), findsOneWidget);
expect(find.byTooltip('从外部导入'), findsOneWidget);
// Verify ordering: note_add_outlined < create_new_folder_outlined < file_upload_outlined
final noteAddOffset = tester.getTopLeft(find.byIcon(Icons.note_add_outlined));
final folderOffset = tester.getTopLeft(find.byIcon(Icons.create_new_folder_outlined));
final importOffset = tester.getTopLeft(find.byIcon(Icons.file_upload_outlined));
expect(noteAddOffset.dx, lessThan(folderOffset.dx));
expect(folderOffset.dx, lessThan(importOffset.dx));
});
testWidgets('Import button shows English tooltip when locale is en', (tester) async {
await tester.pumpWidget(buildTestWidget(locale: const Locale('en')));
final scaffoldState = tester.state<ScaffoldState>(find.byType(Scaffold));
scaffoldState.openDrawer();
await tester.pumpAndSettle();
expect(find.byTooltip('Import from External'), findsOneWidget);
});
testWidgets('Tapping import button imports multiple external files into project root', (tester) async {
final file1 = File(p.join(tempBaseDir.path, 'source1.txt'))..writeAsStringSync('hello world');
final file2 = File(p.join(tempBaseDir.path, 'source2.dart'))..writeAsStringSync('void main() {}');
mockFilePicker.pickedFiles = [
PlatformFile(name: 'source1.txt', size: 11, path: file1.path),
PlatformFile(name: 'source2.dart', size: 16, path: file2.path),
];
await tester.pumpWidget(buildTestWidget(locale: const Locale('zh')));
final scaffoldState = tester.state<ScaffoldState>(find.byType(Scaffold));
scaffoldState.openDrawer();
await tester.pumpAndSettle();
final imported1 = File(p.join(testProjectDir.path, 'source1.txt'));
final imported2 = File(p.join(testProjectDir.path, 'source2.dart'));
await tester.runAsync(() async {
await tester.tap(find.byIcon(Icons.file_upload_outlined));
for (var i = 0; i < 50; i++) {
await Future.delayed(const Duration(milliseconds: 50));
if (imported1.existsSync() && imported2.existsSync()) break;
}
});
await tester.pumpAndSettle();
// Verify files were copied into testProjectDir
expect(imported1.existsSync(), isTrue);
expect(imported1.readAsStringSync(), equals('hello world'));
expect(imported2.existsSync(), isTrue);
expect(imported2.readAsStringSync(), equals('void main() {}'));
// Verify success toast
expect(find.text('成功导入 2 个文件'), findsOneWidget);
await tester.pump(const Duration(seconds: 3));
});
testWidgets('Importing file with duplicate name automatically generates unique filename', (tester) async {
// Existing file in root
File(p.join(testProjectDir.path, 'duplicate.txt')).writeAsStringSync('existing original');
// External file to import
final extFile = File(p.join(tempBaseDir.path, 'duplicate.txt'))..writeAsStringSync('imported copy');
mockFilePicker.pickedFiles = [
PlatformFile(name: 'duplicate.txt', size: 13, path: extFile.path),
];
await tester.pumpWidget(buildTestWidget(locale: const Locale('zh')));
final scaffoldState = tester.state<ScaffoldState>(find.byType(Scaffold));
scaffoldState.openDrawer();
await tester.pumpAndSettle();
final uniqueFile = File(p.join(testProjectDir.path, 'duplicate(1).txt'));
await tester.runAsync(() async {
await tester.tap(find.byIcon(Icons.file_upload_outlined));
for (var i = 0; i < 50; i++) {
await Future.delayed(const Duration(milliseconds: 50));
if (uniqueFile.existsSync()) break;
}
});
await tester.pumpAndSettle();
// Original file remains unchanged
expect(File(p.join(testProjectDir.path, 'duplicate.txt')).readAsStringSync(), equals('existing original'));
// New unique file is created
expect(uniqueFile.existsSync(), isTrue);
expect(uniqueFile.readAsStringSync(), equals('imported copy'));
// Wait for toast to dismiss
await tester.pump(const Duration(seconds: 3));
});
test('ProjectProvider.importFiles supports bytes fallback when path is null', () async {
final bytes = Uint8List.fromList([65, 66, 67]);
final file = PlatformFile(
name: 'bytes_file.txt',
size: 3,
bytes: bytes,
);
final count = await projectProvider.importFiles(testProjectDir.path, [file]);
expect(count, equals(1));
final imported = File(p.join(testProjectDir.path, 'bytes_file.txt'));
expect(imported.existsSync(), isTrue);
expect(imported.readAsStringSync(), equals('ABC'));
});
}
+144
View File
@@ -0,0 +1,144 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:code_editor/services/project_modules/gradle_ide_model.dart';
/// 结构化探测模型测试:取代旧的"文本正则解析"测试。
/// 这些用例断言的是"按字段读取 JSON 模型",与 Gradle 输出措辞/语言/版本无关。
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
Map<String, dynamic> singleProjectModel() => {
'schema': 1,
'gradleVersion': '8.14',
'rootProject': 'demo',
'projects': [
{
'path': ':',
'name': 'demo',
'buildFile': '/workspace/build.gradle',
'plugins': ['org.gradle.api.plugins.JavaPlugin'],
'sourceSets': ['main', 'test'],
'configurations': ['compileClasspath', 'runtimeClasspath'],
'javaVersion': '17',
'tasks': [
{
'name': 'build',
'path': ':build',
'group': 'build',
'description': 'Assembles and tests this project.',
'type': 'org.gradle.api.DefaultTask',
},
{
'name': 'test',
'path': ':test',
'group': 'verification',
'description': null,
'type': 'org.gradle.api.tasks.testing.Test',
},
{
'name': 'tasks',
'path': ':tasks',
'group': 'help',
'description': 'Displays the tasks runnable from root project.',
'type': 'org.gradle.api.DefaultTask',
},
],
},
],
};
group('GradleIdeModel 结构化解析', () {
test('单模块:任务字段、分组归一、id/命令生成与原命名习惯一致', () {
final model = GradleIdeModel.fromJson(singleProjectModel());
expect(model.schema, GradleIdeModel.schemaVersion);
expect(model.gradleVersion, '8.14');
expect(model.projects, hasLength(1));
expect(model.projects.first.sourceSets, ['main', 'test']);
expect(model.projects.first.javaVersion, '17');
final tasks = model.toRunTasks('sh ./gradlew');
expect(tasks, hasLength(3));
final build = tasks.firstWhere((t) => t.name == 'build');
expect(build.id, 'gradle_build');
expect(build.command, 'sh ./gradlew build');
expect(build.group, 'build');
expect(build.description, 'Assembles and tests this project.');
// 分组排序:application > build > android > verification > help
expect(tasks.map((t) => t.name).toList(), ['build', 'test', 'tasks']);
expect(tasks.firstWhere((t) => t.name == 'test').group, 'verification');
});
test('多模块:子项目任务使用 :path 作为名称与命令(保持既有 id 习惯)', () {
final model = GradleIdeModel.fromJson({
'schema': 1,
'rootProject': 'demo',
'projects': [
{
'path': ':',
'name': 'demo',
'tasks': [
{'name': 'build', 'path': ':build', 'group': 'build'},
],
},
{
'path': ':app',
'name': 'app',
'tasks': [
{'name': 'assembleDebug', 'path': ':app:assembleDebug', 'group': 'build'},
],
},
{
'path': ':core',
'name': 'core',
'tasks': [
{'name': 'compileJava', 'path': ':core:compileJava', 'group': 'build'},
],
},
],
});
final tasks = model.toRunTasks('gradle');
final appTask = tasks.firstWhere((t) => t.name == ':app:assembleDebug');
expect(appTask.command, 'gradle :app:assembleDebug');
expect(appTask.id, 'gradle__app_assembleDebug');
expect(appTask.moduleId, 'gradle');
expect(tasks.firstWhere((t) => t.name == ':core:compileJava').id, 'gradle__core_compileJava');
});
test('空任务 / 缺字段 / 重复任务路径都能安全处理', () {
final empty = GradleIdeModel.fromJson({'schema': 1, 'rootProject': 'demo', 'projects': []});
expect(empty.toRunTasks('gradle'), isEmpty);
final missing = GradleIdeModel.fromJson({'schema': 1});
expect(missing.projects, isEmpty);
final duplicated = GradleIdeModel.fromJson({
'schema': 1,
'rootProject': 'demo',
'projects': [
{
'path': ':',
'name': 'demo',
'tasks': [
{'name': 'build', 'path': ':build'},
{'name': 'build', 'path': ':build'},
],
},
],
});
expect(duplicated.toRunTasks('gradle'), hasLength(1));
});
test('schema 不匹配或内部错误时抛出 FormatException(上层归类为不可解析/执行失败)', () {
expect(
() => GradleIdeModel.fromJson({'schema': 0, 'error': 'Gradle 配置阶段抛错'}),
throwsA(isA<FormatException>()),
);
expect(
() => GradleIdeModel.fromJson({'schema': 99}),
throwsA(isA<FormatException>()),
);
});
});
}
+101 -248
View File
@@ -1,209 +1,76 @@
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:path/path.dart' as p;
import 'package:code_editor/models/run_task.dart';
import 'package:code_editor/models/run_task_type.dart';
import 'package:code_editor/providers/run_provider.dart';
import 'package:code_editor/services/project_modules/gradle_project_module.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';
/// 单测用假系统名:探测必须基于"真实可用系统",单测用假 rootfs 代替真容器
const String kTestSystemName = 'test_sys';
/// 固定返回一组任务的假模块(用于验证类型表写入 / RunProvider 集成)
class _StubGradleModule extends ProjectModule {
@override
String get id => 'gradle';
@override
String get displayName => 'Gradle';
@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 => ModuleProbeResult.ok(id, [
const RunTask(
id: 'gradle_assemble',
name: 'assemble',
command: 'sh ./gradlew assemble',
source: TaskSource.detected,
moduleId: 'gradle',
group: 'build',
),
]);
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('GradleProjectModule Parser Tests', () {
test('parseGradleTasksOutput parses single project tasks, groups, and descriptions', () {
const output = '''
------------------------------------------------------------
Tasks runnable from root project 'my-app'
------------------------------------------------------------
Application tasks
-----------------
run - Runs this project as a JVM application
Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
clean - Deletes the build directory.
Verification tasks
------------------
check - Runs all checks.
test - Runs the test suite.
Other tasks
-----------
customTask - Executes a custom task
''';
final tasks = GradleProjectModule.parseGradleTasksOutput(output, 'sh ./gradlew');
expect(tasks, isNotEmpty);
// 验证任务名称与命令
final runTask = tasks.firstWhere((t) => t.name == 'run');
expect(runTask.command, 'sh ./gradlew run');
expect(runTask.group, 'application');
expect(runTask.moduleId, 'gradle');
expect(runTask.source, TaskSource.detected);
expect(runTask.description, 'Runs this project as a JVM application');
final assembleTask = tasks.firstWhere((t) => t.name == 'assemble');
expect(assembleTask.command, 'sh ./gradlew assemble');
expect(assembleTask.group, 'build');
expect(assembleTask.moduleId, 'gradle');
final buildTask = tasks.firstWhere((t) => t.name == 'build');
expect(buildTask.command, 'sh ./gradlew build');
expect(buildTask.group, 'build');
final testTask = tasks.firstWhere((t) => t.name == 'test');
expect(testTask.command, 'sh ./gradlew test');
expect(testTask.group, 'verification');
final customTask = tasks.firstWhere((t) => t.name == 'customTask');
expect(customTask.command, 'sh ./gradlew customTask');
expect(customTask.group, 'other');
expect(customTask.description, 'Executes a custom task');
// 优先级排序验证:application -> build -> verification -> other
final groupsInOrder = tasks.map((t) => t.group).toList();
final appIdx = groupsInOrder.indexOf('application');
final buildIdx = groupsInOrder.indexOf('build');
final verifIdx = groupsInOrder.indexOf('verification');
final otherIdx = groupsInOrder.indexOf('other');
expect(appIdx, lessThan(buildIdx));
expect(buildIdx, lessThan(verifIdx));
expect(verifIdx, lessThan(otherIdx));
});
test('parseGradleTasksOutput parses multi-module projects with prefixes (:app:xxx)', () {
const output = '''
------------------------------------------------------------
Tasks runnable from project ':app'
------------------------------------------------------------
Build tasks
-----------
assembleDebug - Assembles all Debug builds.
assembleRelease - Assembles all Release builds.
Tasks runnable from project ':core'
------------------------------------------------------------
Build tasks
-----------
compileJava - Compiles Java sources.
''';
final tasks = GradleProjectModule.parseGradleTasksOutput(output, 'sh ./gradlew');
expect(tasks.length, 3);
final assembleDebugTask = tasks.firstWhere((t) => t.name == ':app:assembleDebug');
expect(assembleDebugTask.command, 'sh ./gradlew :app:assembleDebug');
expect(assembleDebugTask.id, 'gradle__app_assembleDebug');
expect(assembleDebugTask.group, 'build');
expect(assembleDebugTask.moduleId, 'gradle');
final compileJavaTask = tasks.firstWhere((t) => t.name == ':core:compileJava');
expect(compileJavaTask.command, 'sh ./gradlew :core:compileJava');
expect(compileJavaTask.id, 'gradle__core_compileJava');
});
});
group('Gradle Module Cache & Storage Tests', () {
late Directory tempDir;
late RunTaskStorageService storageService;
setUp(() async {
tempDir = await Directory.systemTemp.createTemp('gradle_module_test_');
storageService = RunTaskStorageService();
});
tearDown(() async {
if (await tempDir.exists()) {
await tempDir.delete(recursive: true);
}
});
test('saveModuleTasks writes to .code_editor/gradle_tasks.json and loadModuleTasks reads it back', () async {
final initial = await storageService.loadModuleTasks(tempDir.path, 'gradle');
expect(initial.tasks, isEmpty);
expect(initial.hash, isNull);
const tasksToSave = [
RunTask(
id: 'gradle_assembleDebug',
name: 'assembleDebug',
command: 'sh ./gradlew assembleDebug',
source: TaskSource.detected,
group: 'build',
moduleId: 'gradle',
description: 'Build debug package',
),
RunTask(
id: 'gradle_run',
name: 'run',
command: 'sh ./gradlew run',
source: TaskSource.detected,
group: 'application',
moduleId: 'gradle',
description: 'Run project',
),
];
await storageService.saveModuleTasks(
projectRoot: tempDir.path,
moduleName: 'gradle',
tasks: tasksToSave,
hash: 'test_hash_12345',
);
// 验证独立持久化文件存在:.code_editor/gradle_tasks.json
final cacheFile = File('${tempDir.path}/.code_editor/gradle_tasks.json');
expect(cacheFile.existsSync(), isTrue);
// 读取并校验
final loaded = await storageService.loadModuleTasks(tempDir.path, 'gradle');
expect(loaded.hash, 'test_hash_12345');
expect(loaded.tasks.length, 2);
expect(loaded.tasks.first.name, 'assembleDebug');
expect(loaded.tasks.first.group, 'build');
expect(loaded.tasks.first.moduleId, 'gradle');
expect(loaded.tasks.last.name, 'run');
// 验证 run_tasks.json(用户任务)完全不受影响且相互隔离
final userConfig = await storageService.loadConfig(tempDir.path);
expect(userConfig.tasks, isEmpty);
});
test('computeBuildScriptHash changes when build.gradle is modified', () async {
final buildGradle = File('${tempDir.path}/build.gradle');
await buildGradle.writeAsString('plugins { id "java" }\n');
final hash1 = GradleProjectModule.computeBuildScriptHash(tempDir);
expect(hash1.isNotEmpty, isTrue);
// 稍微休眠并修改内容
await Future<void>.delayed(const Duration(milliseconds: 50));
await buildGradle.writeAsString('plugins { id "application" }\n');
final hash2 = GradleProjectModule.computeBuildScriptHash(tempDir);
expect(hash2, isNot(equals(hash1)));
});
});
group('ProjectTaskDispatcher & RunProvider Modular Tests', () {
late Directory tempDir;
late Directory distroBaseDir;
late DistroManager distroManager;
setUp(() async {
tempDir = await Directory.systemTemp.createTemp('dispatcher_test_');
// 假系统:rootfs/{etc,bin,usr/bin/java}(依赖检测走宿主 rootfs 快速判定)
distroBaseDir = await Directory.systemTemp.createTemp('dispatcher_distro_');
final rootfs = Directory(p.join(distroBaseDir.path, kTestSystemName, 'rootfs'));
Directory(p.join(rootfs.path, 'etc')).createSync(recursive: true);
Directory(p.join(rootfs.path, 'bin')).createSync(recursive: true);
final usrBin = Directory(p.join(rootfs.path, 'usr', 'bin'))..createSync(recursive: true);
File(p.join(usrBin.path, 'java')).writeAsStringSync('#!/bin/sh\n');
distroManager = DistroManager()..customBaseDir = distroBaseDir;
});
tearDown(() async {
DistroManager().customBaseDir = null;
if (await tempDir.exists()) {
await tempDir.delete(recursive: true);
}
if (await distroBaseDir.exists()) {
await distroBaseDir.delete(recursive: true);
}
});
test('ProjectTaskDispatcher activates modules correctly', () async {
@@ -226,80 +93,66 @@ compileJava - Compiles Java sources.
expect(active2.any((m) => m.id == 'gradle'), isTrue);
});
test('GradleProjectModule returns cached tasks when hash matches without executing command', () async {
final buildGradle = File('${tempDir.path}/build.gradle');
await buildGradle.writeAsString('plugins { id "java" }\n');
test('未安装指定系统时既不探测,也绝不创建任何系统目录', () async {
final emptyBase = await Directory.systemTemp.createTemp('dispatcher_no_sys_');
addTearDown(() async {
if (await emptyBase.exists()) await emptyBase.delete(recursive: true);
});
DistroManager().customBaseDir = emptyBase;
final storageService = RunTaskStorageService();
final currentHash = GradleProjectModule.computeBuildScriptHash(tempDir);
await File('${tempDir.path}/build.gradle').writeAsString('plugins { id "java" }\n');
const cachedTasks = [
RunTask(
id: 'gradle_cached_task',
name: 'cachedTask',
command: 'sh ./gradlew cachedTask',
source: TaskSource.detected,
group: 'build',
moduleId: 'gradle',
),
];
await storageService.saveModuleTasks(
final tasks = await ProjectTaskDispatcher().detect(
projectRoot: tempDir.path,
moduleName: 'gradle',
tasks: cachedTasks,
hash: currentHash,
systemName: 'ubuntu',
distroManager: DistroManager(),
);
final dispatcher = ProjectTaskDispatcher();
final tasks = await dispatcher.detect(
projectRoot: tempDir.path,
storageService: storageService,
);
expect(tasks.any((t) => t.id == 'gradle_cached_task'), isTrue);
expect(tasks.firstWhere((t) => t.id == 'gradle_cached_task').name, 'cachedTask');
expect(tasks, isEmpty);
// 绝不能凭空造出 distros/ubuntu(历史缺陷会在这里 recursive 创建 rootfs/etc)
expect(Directory(p.join(emptyBase.path, 'ubuntu')).existsSync(), isFalse);
});
test('RunProvider integrates with modular task system and maintains customTasks', () async {
final storageService = RunTaskStorageService();
final runProvider = RunProvider(storageService: storageService);
// 准备工程与一个已缓存的 Gradle 任务
test('未传入系统名时不做任何探测(连纯静态模块任务也不产出)', () async {
await File('${tempDir.path}/Makefile').writeAsString('all:\n\tgcc main.c\n');
await File('${tempDir.path}/build.gradle').writeAsString('plugins { id "java" }\n');
final currentHash = GradleProjectModule.computeBuildScriptHash(tempDir);
const initialGradleTask = RunTask(
id: 'gradle_assemble',
name: 'assemble',
command: 'sh ./gradlew assemble',
source: TaskSource.detected,
group: 'build',
moduleId: 'gradle',
);
await storageService.saveModuleTasks(
final tasks = await ProjectTaskDispatcher().detect(
projectRoot: tempDir.path,
moduleName: 'gradle',
tasks: [initialGradleTask],
hash: currentHash,
distroManager: distroManager,
);
// 打开工程
await runProvider.onProjectOpened(tempDir.path);
expect(tasks, isEmpty);
});
test('真实自省失败时返回空结果:不产出任何兜底任务', () async {
await File('${tempDir.path}/build.gradle').writeAsString('plugins { id "java" }\n');
final tasks = await ProjectTaskDispatcher().detect(
projectRoot: tempDir.path,
systemName: kTestSystemName,
distroManager: distroManager,
);
// 测试环境无法真正执行 gradle -> 该模块失败且不产出任务(也绝无 detected_gradle_* 兜底)
expect(tasks.where((t) => t.moduleId == 'gradle'), isEmpty);
expect(tasks.any((t) => t.id.startsWith('detected_gradle_')), isFalse);
});
test('RunProvider 集成:模块结果写入"类型 → 任务数组"的对应格子', () async {
await File('${tempDir.path}/build.gradle').writeAsString('plugins { id "java" }\n');
final dispatcher = ProjectTaskDispatcher(customModules: [_StubGradleModule()]);
final runProvider = RunProvider(
dispatcher: dispatcher,
distroManager: distroManager,
);
await runProvider.onProjectOpened(tempDir.path, systemName: kTestSystemName);
expect(runProvider.taskTable.tasksOf(RunTaskType.gradle).map((t) => t.id), ['gradle_assemble']);
expect(runProvider.detectedTasks.any((t) => t.id == 'gradle_assemble'), isTrue);
// 添加用户自定义任务
const customTask = RunTask(
id: 'user_custom_1',
name: 'My Custom Run',
command: 'echo "custom"',
source: TaskSource.custom,
);
await runProvider.addCustomTask(customTask);
expect(runProvider.customTasks.length, 1);
// allTasks 自定义置顶
expect(runProvider.allTasks.first.id, 'user_custom_1');
expect(runProvider.allTasks.any((t) => t.id == 'gradle_assemble'), isTrue);
expect(runProvider.taskTable.tasksOf(RunTaskType.user), isEmpty);
});
});
}
+111
View File
@@ -0,0 +1,111 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:code_editor/models/notice_item.dart';
import 'package:code_editor/providers/notice_center.dart';
void main() {
NoticeItem progress(String id, {String module = 'Gradle'}) => NoticeItem(
id: id,
kind: NoticeKind.progress,
text: ModulePhaseText(moduleDisplayName: module, phase: ProbeNoticePhase.detecting),
);
group('NoticeCenter 通知队列', () {
test('可视槽位未满时直接展示,超限后进入队列', () {
final center = NoticeCenter(visibleLimit: 2);
center.push(progress('probe:gradle'));
center.push(progress('probe:npm'));
expect(center.visible.map((e) => e.id).toList(), ['probe:npm', 'probe:gradle']);
expect(center.queued, isEmpty);
center.push(progress('probe:make'));
expect(center.visible, hasLength(2));
expect(center.queued.map((e) => e.id).toList(), ['probe:make']);
});
test('关闭一条后,队列首条自动补位(弹窗关闭自动弹出)', () {
final center = NoticeCenter(visibleLimit: 1);
center.push(progress('probe:gradle'));
center.push(progress('probe:npm'));
// 先进入"正在移除"(UI 播退场动画),真正移除前队列不补位
center.dismiss('probe:gradle');
expect(center.removingIds, contains('probe:gradle'));
expect(center.visible, hasLength(1));
expect(center.queued, hasLength(1));
// 动画结束回调 -> 移除 + 补位
center.finalizeDismiss('probe:gradle');
expect(center.visible.map((e) => e.id).toList(), ['probe:npm']);
expect(center.queued, isEmpty);
expect(center.removingIds, isEmpty);
});
test('队列中的条目被关闭时直接移除并立即补位', () {
final center = NoticeCenter(visibleLimit: 1);
center.push(progress('probe:gradle'));
center.push(progress('probe:npm'));
center.dismiss('probe:npm');
expect(center.queued, isEmpty);
expect(center.visible.map((e) => e.id).toList(), ['probe:gradle']);
});
test('update 就地更新文案但不改变位置', () {
final center = NoticeCenter(visibleLimit: 3);
center.push(progress('probe:gradle'));
center.push(progress('probe:npm'));
center.update(
'probe:gradle',
text: const ModulePhaseText(
moduleDisplayName: 'Gradle',
phase: ProbeNoticePhase.checkingDependency,
),
);
expect(center.visible.map((e) => e.id).toList(), ['probe:npm', 'probe:gradle']);
final gradle = center.visible.last;
expect((gradle.text as ModulePhaseText).phase, ProbeNoticePhase.checkingDependency);
});
testWidgets('complete 带 autoCloseAfter 时延时自动关闭;sticky 则保留', (tester) async {
await tester.pumpWidget(const SizedBox());
final center = NoticeCenter(visibleLimit: 3);
center.push(progress('probe:gradle'));
center.push(progress('probe:npm'));
// 成功:1 秒后自动进入移除流程
center.complete('probe:gradle', kind: NoticeKind.success, autoCloseAfter: const Duration(seconds: 1));
await tester.pump(const Duration(milliseconds: 900));
expect(center.removingIds, isEmpty);
await tester.pump(const Duration(milliseconds: 200));
expect(center.removingIds, contains('probe:gradle'));
// 失败:sticky 不自动关闭
center.complete(
'probe:npm',
kind: NoticeKind.failure,
text: const ModuleFailureText(
moduleDisplayName: 'NPM',
failure: NoticeFailure.toolchainMissing,
detail: 'npm',
),
sticky: true,
);
await tester.pump(const Duration(seconds: 30));
expect(center.removingIds, isNot(contains('probe:npm')));
expect(center.visible.map((e) => e.id), contains('probe:npm'));
});
testWidgets('dismissAll 清空可见与队列,并取消所有自动关闭定时器', (tester) async {
await tester.pumpWidget(const SizedBox());
final center = NoticeCenter(visibleLimit: 1);
center.push(progress('probe:gradle'));
center.complete('probe:gradle', kind: NoticeKind.success, autoCloseAfter: const Duration(seconds: 5));
center.push(progress('probe:npm'));
center.dismissAll();
expect(center.isEmpty, isTrue);
// 定时器已取消:不会在之后触发任何状态变化
await tester.pump(const Duration(seconds: 10));
expect(center.isEmpty, isTrue);
});
});
}
+189
View File
@@ -0,0 +1,189 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:code_editor/l10n/app_localizations.dart';
import 'package:code_editor/models/notice_item.dart';
import 'package:code_editor/providers/notice_center.dart';
import 'package:code_editor/widgets/notice_host.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
Widget buildHost(NoticeCenter center, {Locale locale = const Locale('zh')}) {
return MaterialApp(
locale: locale,
localizationsDelegates: AppLocalizations.localizationsDelegates,
supportedLocales: AppLocalizations.supportedLocales,
home: Scaffold(
body: SizedBox(
width: 400,
height: 400,
child: Stack(
children: [
Positioned.fill(child: NoticeHost(center: center)),
],
),
),
),
);
}
/// 推进动画:注意"进行中"通知里的 CircularProgressIndicator 是无限动画,
/// 因此这里必须用显式 pump(duration),不能用 pumpAndSettle。
Future<void> advance(WidgetTester tester, [int ms = 400]) async {
await tester.pump();
await tester.pump(Duration(milliseconds: ms));
}
NoticeItem phaseNotice(
String id, {
String module = 'Gradle',
ProbeNoticePhase phase = ProbeNoticePhase.detecting,
}) =>
NoticeItem(
id: id,
kind: NoticeKind.progress,
text: ModulePhaseText(moduleDisplayName: module, phase: phase),
);
group('NoticeHost 通知堆叠宿主', () {
testWidgets('空队列时不渲染任何内容', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(buildHost(center));
await tester.pumpAndSettle();
expect(find.textContaining('Gradle'), findsNothing);
});
testWidgets('可同时插入多条通知,文案来自 l10n(中文)', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(buildHost(center));
await tester.pumpAndSettle();
center.push(phaseNotice('probe:gradle', module: 'Gradle'));
center.push(phaseNotice('probe:npm', module: 'NPM'));
await advance(tester);
expect(find.text('正在探测 Gradle 任务…'), findsOneWidget);
expect(find.text('正在探测 NPM 任务…'), findsOneWidget);
});
testWidgets('英文环境下同一模型渲染为英文文案(零硬编码)', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(buildHost(center, locale: const Locale('en')));
await tester.pumpAndSettle();
center.push(phaseNotice('probe:gradle', module: 'Gradle'));
await advance(tester);
expect(find.text('Detecting Gradle tasks…'), findsOneWidget);
expect(find.text('正在探测 Gradle 任务…'), findsNothing);
});
testWidgets('插入动画:可见透明度在动画中途介于 0~1', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(buildHost(center));
await tester.pumpAndSettle();
center.push(phaseNotice('probe:gradle'));
await tester.pump(); // 动画起点
await tester.pump(const Duration(milliseconds: 90)); // 动画中途
final midwayOpacity = tester
.widgetList<FadeTransition>(find.byType(FadeTransition))
.map((w) => w.opacity.value)
.toList();
expect(midwayOpacity.any((v) => v > 0 && v < 1), isTrue,
reason: '插入过程中应能观测到透明度介于 0~1 的中间态');
await tester.pump(const Duration(milliseconds: 400));
final settledOpacity = tester
.widgetList<FadeTransition>(find.byType(FadeTransition))
.map((w) => w.opacity.value)
.toList();
expect(settledOpacity.every((v) => v == 1.0), isTrue);
});
testWidgets('点击关闭按钮:退场动画后条目消失', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(buildHost(center));
await tester.pumpAndSettle();
center.push(phaseNotice('probe:gradle'));
await advance(tester);
expect(find.text('正在探测 Gradle 任务…'), findsOneWidget);
await tester.tap(find.byIcon(Icons.close));
await tester.pump();
await tester.pump(const Duration(milliseconds: 60)); // 退场动画中
expect(center.removingIds, contains('probe:gradle'));
await tester.pump(const Duration(milliseconds: 400)); // 退场动画结束
expect(find.text('正在探测 Gradle 任务…'), findsNothing);
expect(center.visible, isEmpty);
});
testWidgets('超过可视上限的通知进入队列,关闭一条后自动补位弹出', (tester) async {
final center = NoticeCenter(visibleLimit: 2);
await tester.pumpWidget(buildHost(center));
await tester.pumpAndSettle();
center.push(phaseNotice('probe:gradle', module: 'Gradle'));
center.push(phaseNotice('probe:npm', module: 'NPM'));
center.push(phaseNotice('probe:make', module: 'Makefile'));
await advance(tester);
expect(find.text('正在探测 Makefile 任务…'), findsNothing);
expect(find.text('还有 1 项进行中'), findsOneWidget);
// 关闭一条 -> 队列首条自动弹出
center.dismiss('probe:npm');
await advance(tester, 600);
expect(find.text('正在探测 Makefile 任务…'), findsOneWidget);
expect(find.text('还有 1 项进行中'), findsNothing);
});
testWidgets('失败通知显示模块标题 + 结构化原因(toolchainMissing)', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(buildHost(center));
await tester.pumpAndSettle();
center.push(NoticeItem(
id: 'probe:gradle',
kind: NoticeKind.failure,
text: const ModuleFailureText(
moduleDisplayName: 'Gradle',
failure: NoticeFailure.toolchainMissing,
detail: 'gradle',
),
sticky: true,
));
await tester.pumpAndSettle();
expect(find.text('Gradle 任务探测失败'), findsOneWidget);
expect(find.text('当前系统内未找到 gradle,请先在系统管理中安装'), findsOneWidget);
});
testWidgets('完成通知自动关闭后完全消失', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(buildHost(center));
await tester.pumpAndSettle();
center.push(phaseNotice('probe:gradle'));
await advance(tester);
// 成功 -> 转为"已完成"静态卡片,并在 autoCloseAfter 后自动关闭
center.complete(
'probe:gradle',
kind: NoticeKind.success,
text: const ModuleDoneText('Gradle', taskCount: 3),
autoCloseAfter: const Duration(milliseconds: 200),
);
await tester.pump();
await tester.pump(const Duration(milliseconds: 100));
expect(find.text('Gradle 探测完成 · 发现 3 个任务'), findsOneWidget);
await tester.pump(const Duration(milliseconds: 300));
await tester.pump(const Duration(milliseconds: 400));
expect(find.text('Gradle 探测完成 · 发现 3 个任务'), findsNothing);
expect(center.visible, isEmpty);
});
});
}
+721
View File
@@ -0,0 +1,721 @@
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);
});
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);
});
});
}
+147
View File
@@ -0,0 +1,147 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:code_editor/l10n/app_localizations.dart';
import 'package:code_editor/models/notice_item.dart';
import 'package:code_editor/providers/notice_center.dart';
import 'package:code_editor/widgets/notice_host.dart';
import 'package:code_editor/widgets/probe_cancel_guard.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
Widget wrap(Widget child, {Locale locale = const Locale('zh')}) => MaterialApp(
locale: locale,
localizationsDelegates: AppLocalizations.localizationsDelegates,
supportedLocales: AppLocalizations.supportedLocales,
home: Scaffold(body: Stack(children: [Positioned.fill(child: child)])),
);
NoticeItem progressNotice({bool confirm = true, VoidCallback? onDismiss}) => NoticeItem(
id: 'probe:gradle',
kind: NoticeKind.progress,
text: const ModulePhaseText(
moduleDisplayName: 'Gradle',
phase: ProbeNoticePhase.detecting,
),
onUserDismiss: onDismiss,
confirmBeforeDismiss: confirm,
);
Future<void> settle(WidgetTester tester) async {
// 进行中的通知含无限进度圈,不能用 pumpAndSettle
await tester.pump();
await tester.pump(const Duration(milliseconds: 400));
}
group('取消探测的二次确认', () {
testWidgets('确认弹窗文案与按钮来自 l10n(取消 => 探测继续)', (tester) async {
final results = <bool>[];
await tester.pumpWidget(wrap(Builder(
builder: (context) => Center(
child: ElevatedButton(
onPressed: () async => results.add(await confirmCancelProbe(context)),
child: const Text('cancel'),
),
),
)));
await tester.pumpAndSettle();
await tester.tap(find.text('cancel'));
await tester.pumpAndSettle();
expect(find.text('取消本次探测?'), findsOneWidget);
expect(find.textContaining('未完成的模块将被跳过'), findsOneWidget);
await tester.tap(find.text('继续探测'));
await tester.pumpAndSettle();
expect(results, [false], reason: '"继续探测" => 不取消');
});
testWidgets('点"取消探测" => 确认取消', (tester) async {
final results = <bool>[];
await tester.pumpWidget(wrap(Builder(
builder: (context) => Center(
child: ElevatedButton(
onPressed: () async => results.add(await confirmCancelProbe(context)),
child: const Text('cancel'),
),
),
)));
await tester.pumpAndSettle();
await tester.tap(find.text('cancel'));
await tester.pumpAndSettle();
await tester.tap(find.text('取消探测'));
await tester.pumpAndSettle();
expect(results, [true]);
});
testWidgets('NoticeHost:confirmBeforeDismiss 为 false 时直接关闭(不弹确认)', (tester) async {
final center = NoticeCenter();
var dismissedByUser = false;
await tester.pumpWidget(wrap(NoticeHost(
center: center,
confirmDismissBuilder: confirmCancelProbe,
)));
await tester.pumpAndSettle();
center.push(progressNotice(confirm: false, onDismiss: () => dismissedByUser = true));
await settle(tester);
await tester.tap(find.byIcon(Icons.close));
await tester.pump();
await tester.pump(const Duration(milliseconds: 400));
expect(find.text('取消本次探测?'), findsNothing);
expect(dismissedByUser, isTrue);
expect(center.visible, isEmpty);
});
testWidgets('NoticeHost:在确认弹窗里选"继续探测" => 卡片保留、附加动作不执行', (tester) async {
final center = NoticeCenter();
var dismissedByUser = false;
await tester.pumpWidget(wrap(NoticeHost(
center: center,
confirmDismissBuilder: confirmCancelProbe,
)));
await tester.pumpAndSettle();
center.push(progressNotice(onDismiss: () => dismissedByUser = true));
await settle(tester);
await tester.tap(find.byIcon(Icons.close));
await settle(tester);
expect(find.text('取消本次探测?'), findsOneWidget);
await tester.tap(find.text('继续探测'));
await settle(tester);
expect(dismissedByUser, isFalse, reason: '放弃取消 => 不得执行"取消探测"动作');
expect(center.visible, hasLength(1), reason: '卡片必须保留');
});
testWidgets('NoticeHost:确认"取消探测" => 执行附加动作并移除卡片', (tester) async {
final center = NoticeCenter();
var dismissedByUser = false;
await tester.pumpWidget(wrap(NoticeHost(
center: center,
confirmDismissBuilder: confirmCancelProbe,
)));
await tester.pumpAndSettle();
center.push(progressNotice(onDismiss: () => dismissedByUser = true));
await settle(tester);
await tester.tap(find.byIcon(Icons.close));
await settle(tester);
await tester.tap(find.text('取消探测'));
await tester.pump();
await tester.pump(const Duration(milliseconds: 400));
expect(dismissedByUser, isTrue);
expect(center.visible, isEmpty);
});
});
}
+223
View File
@@ -0,0 +1,223 @@
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:path/path.dart' as p;
import 'package:code_editor/providers/run_provider.dart';
import 'package:code_editor/services/distro_manager.dart';
import 'package:code_editor/services/project_modules/gradle_ide_model.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_modules/standard_project_modules.dart';
import 'package:code_editor/services/project_task_dispatcher.dart';
import 'package:code_editor/services/run_task_storage_service.dart';
class _CancellingModule extends ProjectModule {
@override
final String id;
final Duration delay;
final void Function(ProjectProbe probe)? onProbe;
_CancellingModule(this.id, {this.delay = Duration.zero, this.onProbe});
@override
String get displayName => id;
@override
List<String> get triggerFiles => const [];
@override
bool shouldActivate(Directory projectDir) => true;
@override
Future<ModuleProbeResult> probe(ProjectProbe probe) async {
onProbe?.call(probe);
if (delay > Duration.zero) {
await Future<void>.delayed(delay);
}
if (probe.isCancelled) return ModuleProbeResult.cancelled(id);
return ModuleProbeResult.ok(id, const []);
}
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('Probe System Logic Bug Fixes Verification', () {
late Directory tempDir;
late Directory distroBaseDir;
late DistroManager distroManager;
const systemName = 'test_sys';
setUp(() async {
tempDir = await Directory.systemTemp.createTemp('probe_fix_test_');
distroBaseDir = await Directory.systemTemp.createTemp('probe_fix_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;
if (await tempDir.exists()) await tempDir.delete(recursive: true);
if (await distroBaseDir.exists()) await distroBaseDir.delete(recursive: true);
});
test('1. detectSingleFileTask 安全包裹单引号与 -lm 数学库', () {
final fileWithDollar = File(p.join(tempDir.path, 'test\$1.c'))..writeAsStringSync('int main() {}');
final task = ProjectTaskDispatcher.detectSingleFileTask(tempDir.path, fileWithDollar.path);
expect(task, isNotNull);
// 命令必须包含单引号包裹和 -lm
expect(task!.command, contains(r"gcc './test$1.c' -lm -o /tmp/a.out && /tmp/a.out"));
final pyFile = File(p.join(tempDir.path, 'hello world.py'))..writeAsStringSync('print()');
final pyTask = ProjectTaskDispatcher.detectSingleFileTask(tempDir.path, pyFile.path);
expect(pyTask, isNotNull);
expect(pyTask!.command, equals("python3 './hello world.py'"));
});
test('2. CargoProjectModule._declaredBinaryNames 过滤注释并支持带空格的 [[ bin ]]', () async {
File(p.join(tempDir.path, 'Cargo.toml')).writeAsStringSync('''
[package]
name = "my_pkg"
version = "0.1.0"
[[ bin ]]
name = "server" # inline comment
[[bin]]
name = "client"
''');
final probe = ProjectProbe(
request: ProjectProbeRequest(
projectDir: tempDir,
systemName: systemName,
),
distroManager: distroManager,
);
final cargoModule = CargoProjectModule();
expect(cargoModule.shouldActivate(tempDir), isTrue);
final res = await cargoModule.probe(probe);
expect(res.tasks.map((t) => t.id), containsAll(['cargo_run_server', 'cargo_run_client']));
final serverTask = res.tasks.firstWhere((t) => t.id == 'cargo_run_server');
expect(serverTask.command, equals('cargo run --bin server'));
});
test('3. CMakeProjectModule 解析 add_executable 并包裹单引号', () async {
File(p.join(tempDir.path, 'CMakeLists.txt')).writeAsStringSync('''
cmake_minimum_required(VERSION 3.10)
project(MyAwesomeProject)
add_executable(app_binary main.cpp)
''');
final probe = ProjectProbe(
request: ProjectProbeRequest(
projectDir: tempDir,
systemName: systemName,
),
distroManager: distroManager,
);
final cmakeModule = CMakeProjectModule();
final res = await cmakeModule.probe(probe);
expect(res.status, ModuleProbeStatus.ok);
final runTask = res.tasks.firstWhere((t) => t.id == 'detected_cmake_build_run');
expect(runTask.command, contains("'./build/app_binary'"));
});
test('4. 取消探测时队列中所有未开始模块均完整记录为 cancelled', () async {
final m1 = _CancellingModule('m1', delay: const Duration(milliseconds: 20), onProbe: (probe) {
// 在 m1 执行时取消 probe
probe.cancel();
});
final m2 = _CancellingModule('m2');
final m3 = _CancellingModule('m3');
final dispatcher = ProjectTaskDispatcher(customModules: [m1, m2, m3]);
final probe = dispatcher.createProbe(
projectRoot: tempDir.path,
systemName: systemName,
distroManager: distroManager,
);
final report = await dispatcher.run(probe);
expect(probe.isCancelled, isTrue);
// 全部激活模块均应在 moduleResults 中有记录
expect(report.moduleResults.keys, containsAll(['m1', 'm2', 'm3']));
expect(report.moduleResults['m1']?.status, ModuleProbeStatus.cancelled);
expect(report.moduleResults['m2']?.status, ModuleProbeStatus.cancelled);
expect(report.moduleResults['m3']?.status, ModuleProbeStatus.cancelled);
});
test('5. probeSystem 开始新探测时自动终止正在进行的旧探测', () async {
final storage = RunTaskStorageService();
final mLong = _CancellingModule('long', delay: const Duration(milliseconds: 200));
final provider = RunProvider(
storageService: storage,
dispatcher: ProjectTaskDispatcher(customModules: [mLong]),
distroManager: distroManager,
);
// 启动第 1 次探测
final f1 = provider.probeSystem(projectRoot: tempDir.path, systemName: systemName);
await Future<void>.delayed(const Duration(milliseconds: 20));
expect(provider.isDetecting, isTrue);
final active1 = provider.activeProbeForTest;
// 启动第 2 次探测:应该先 cancel 掉第 1 次
final f2 = provider.probeSystem(projectRoot: tempDir.path, systemName: systemName);
expect(active1?.isCancelled, isTrue);
await Future.wait([f1, f2]);
});
test('6. SingleFileTaskDetector 独立模块支持 8 种语言并正确处理委托', () {
final root = tempDir.path;
final exts = {
'a.py': 'python3',
'a.c': 'gcc',
'a.cpp': 'g++',
'a.sh': 'sh',
'a.dart': 'dart run',
'a.go': 'go run',
'a.rs': 'rustc',
'a.js': 'node',
};
for (final entry in exts.entries) {
final filePath = p.join(root, entry.key);
File(filePath).writeAsStringSync('// dummy');
expect(SingleFileTaskDetector.isSupported(filePath), isTrue);
final task = SingleFileTaskDetector.detect(root, filePath);
expect(task, isNotNull);
expect(task!.command, contains(entry.value));
// 验证 ProjectTaskDispatcher.detectSingleFileTask 委托结果一致
final delegatedTask = ProjectTaskDispatcher.detectSingleFileTask(root, filePath);
expect(delegatedTask, isNotNull);
expect(delegatedTask!.id, equals(task.id));
}
});
test('7. GradleIdeModel.fromJson 解析 schema: 0 包含具体 error 消息的 FormatException', () {
final jsonWithError = {
'schema': 0,
'error': 'org.gradle.api.tasks.TaskInstantiationException: failed',
};
expect(
() => GradleIdeModel.fromJson(jsonWithError),
throwsA(
isA<FormatException>().having(
(e) => e.message,
'message',
contains('org.gradle.api.tasks.TaskInstantiationException: failed'),
),
),
);
});
});
}
+316
View File
@@ -0,0 +1,316 @@
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:path/path.dart' as p;
import 'package:code_editor/models/notice_item.dart';
import 'package:code_editor/models/project_task_table.dart';
import 'package:code_editor/models/run_task.dart';
import 'package:code_editor/models/run_task_type.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';
/// 记录执行时序的假模块:用于验证"队列线性执行 + 三动作顺序"
class _FakeModule extends ProjectModule {
@override
final String id;
final List<String> log;
final List<RunTask> tasks;
final bool probeFails;
/// 首次依赖检测返回缺失,安装成功后复检返回空
List<String> _pendingDependencies;
final bool installSucceeds;
final Duration probeDelay;
/// 并发探针:probe 执行期间 +1,用于断言"线性执行、无重叠"
final ValueNotifier<int> concurrency;
_FakeModule({
required this.id,
required this.log,
required this.concurrency,
this.tasks = const [],
this.probeFails = false,
List<String> pendingDependencies = const [],
this.installSucceeds = true,
this.probeDelay = Duration.zero,
}) : _pendingDependencies = pendingDependencies;
@override
String get displayName => id;
@override
List<String> get triggerFiles => const [];
@override
bool shouldActivate(Directory projectDir) => true;
@override
Future<void> prepare(ProjectProbe probe) async {
log.add('$id:prepare');
}
@override
Future<List<String>> checkDependencies(ProjectProbe probe) async {
log.add('$id:check');
return _pendingDependencies;
}
@override
Future<bool> installDependencies(ProjectProbe probe, List<String> missing) async {
log.add('$id:install:${missing.join(",")}');
if (installSucceeds) {
_pendingDependencies = const [];
}
return installSucceeds;
}
@override
Future<ModuleProbeResult> probe(ProjectProbe probe) async {
log.add('$id:probe');
concurrency.value = concurrency.value + 1;
// 同一时刻只允许一个模块处于探测中(队列线性执行的硬约束)
expect(concurrency.value, 1, reason: '队列必须线性执行,不允许两个模块同时探测');
if (probeDelay > Duration.zero) {
await Future<void>.delayed(probeDelay);
}
concurrency.value = concurrency.value - 1;
if (probeFails) {
return ModuleProbeResult.failed(
id,
failure: NoticeFailure.executionFailed,
detail: 'boom',
);
}
return ModuleProbeResult.ok(id, tasks);
}
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
late Directory projectDir;
late Directory distroBaseDir;
late DistroManager distroManager;
const systemName = 'test_sys';
setUp(() async {
projectDir = await Directory.systemTemp.createTemp('probe_queue_project_');
// 假系统:rootfs/{etc,bin,usr/bin/java}
distroBaseDir = await Directory.systemTemp.createTemp('probe_queue_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);
final usrBin = Directory(p.join(rootfs.path, 'usr', 'bin'))..createSync(recursive: true);
File(p.join(usrBin.path, 'java')).writeAsStringSync('#!/bin/sh\n');
distroManager = DistroManager()..customBaseDir = distroBaseDir;
});
tearDown(() async {
DistroManager().customBaseDir = null;
if (await projectDir.exists()) await projectDir.delete(recursive: true);
if (await distroBaseDir.exists()) await distroBaseDir.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 log = <String>[];
final concurrency = ValueNotifier<int>(0);
final dispatcher = ProjectTaskDispatcher(customModules: [
_FakeModule(
id: 'gradle',
log: log,
concurrency: concurrency,
tasks: [task('gradle_build', 'gradle')],
probeDelay: const Duration(milliseconds: 20),
),
_FakeModule(
id: 'cmake',
log: log,
concurrency: concurrency,
probeFails: true,
probeDelay: const Duration(milliseconds: 20),
),
_FakeModule(
id: 'npm',
log: log,
concurrency: concurrency,
tasks: [task('npm_start', 'npm')],
probeDelay: const Duration(milliseconds: 20),
),
]);
final emitted = <String>[];
final probe = dispatcher.createProbe(
projectRoot: projectDir.path,
systemName: systemName,
distroManager: distroManager,
);
final report = await dispatcher.run(
probe,
onModuleResult: (module, result) => emitted.add('${module.id}:${result.status.name}'),
);
probe.dispose();
// 严格线性:a 全套 → b 全套 → c 全套
expect(log, [
'gradle:prepare', 'gradle:check', 'gradle:probe',
'cmake:prepare', 'cmake:check', 'cmake:probe',
'npm:prepare', 'npm:check', 'npm:probe',
]);
expect(concurrency.value, 0);
// 失败模块不影响后续模块执行,结果逐模块上抛
expect(emitted, ['gradle:ok', 'cmake:failed', 'npm:ok']);
expect(report.moduleResults['cmake']!.status, ModuleProbeStatus.failed);
expect(report.detectedTasks.map((t) => t.id), containsAll(['gradle_build', 'npm_start']));
});
test('依赖检测 → 自动补全 → 复检 → 执行探测(顺序固定)', () async {
final log = <String>[];
final concurrency = ValueNotifier<int>(0);
final module = _FakeModule(
id: 'gradle',
log: log,
concurrency: concurrency,
tasks: [task('gradle_build', 'gradle')],
pendingDependencies: const ['gradle'],
);
final dispatcher = ProjectTaskDispatcher(customModules: [module]);
final probe = dispatcher.createProbe(
projectRoot: projectDir.path,
systemName: systemName,
distroManager: distroManager,
);
final report = await dispatcher.run(probe);
probe.dispose();
expect(log, [
'gradle:prepare',
'gradle:check',
'gradle:install:gradle',
'gradle:check',
'gradle:probe',
]);
expect(report.moduleResults['gradle']!.status, ModuleProbeStatus.ok);
});
test('依赖自动补全失败:该模块标记 dependencyInstallFailed,后续模块照常执行', () async {
final log = <String>[];
final concurrency = ValueNotifier<int>(0);
final dispatcher = ProjectTaskDispatcher(customModules: [
_FakeModule(
id: 'gradle',
log: log,
concurrency: concurrency,
installSucceeds: false,
pendingDependencies: const ['gradle'],
),
_FakeModule(id: 'make', log: log, concurrency: concurrency, tasks: [task('make_default', 'make')]),
]);
final probe = dispatcher.createProbe(
projectRoot: projectDir.path,
systemName: systemName,
distroManager: distroManager,
);
final report = await dispatcher.run(probe);
probe.dispose();
final gradleResult = report.moduleResults['gradle']!;
expect(gradleResult.status, ModuleProbeStatus.failed);
expect(gradleResult.failure, NoticeFailure.dependencyInstallFailed);
// 没有进入 probe 阶段
expect(log.contains('gradle:probe'), isFalse);
// 后续模块照常完成
expect(report.moduleResults['make']!.status, ModuleProbeStatus.ok);
expect(log.contains('make:probe'), isTrue);
});
test('无可用系统时不入队、不探测、也不创建任何目录', () async {
final emptyBase = await Directory.systemTemp.createTemp('probe_queue_empty_');
addTearDown(() async {
if (await emptyBase.exists()) await emptyBase.delete(recursive: true);
});
DistroManager().customBaseDir = emptyBase;
final log = <String>[];
final concurrency = ValueNotifier<int>(0);
final dispatcher = ProjectTaskDispatcher(customModules: [
_FakeModule(id: 'gradle', log: log, concurrency: concurrency),
]);
final probe = dispatcher.createProbe(
projectRoot: projectDir.path,
systemName: 'ubuntu',
distroManager: DistroManager(),
);
final report = await dispatcher.run(probe);
probe.dispose();
expect(report.detectedTasks, isEmpty);
expect(log, isEmpty);
expect(Directory(p.join(emptyBase.path, 'ubuntu')).existsSync(), isFalse);
});
});
group('任务类型表(类型 → 任务数组)', () {
test('RunTaskType.ofTask 映射:模块任务 / 单文件 / 用户任务', () {
expect(RunTaskType.ofTask(task('gradle_build', 'gradle')), RunTaskType.gradle);
expect(RunTaskType.ofTask(task('cmake_build', 'cmake')), RunTaskType.cmake);
expect(
RunTaskType.ofTask(const RunTask(
id: 'detected_single_python',
name: 'py',
command: 'python3 x.py',
source: TaskSource.detected,
group: 'single_file',
)),
RunTaskType.singleFile,
);
expect(
RunTaskType.ofTask(const RunTask(
id: 'user_1',
name: 'custom',
command: 'echo',
source: TaskSource.custom,
)),
RunTaskType.user,
);
});
test('模块只写入自己类型那一格,用户任务固定在最后', () {
final table = ProjectTaskTable();
table.replaceType(RunTaskType.gradle, [task('gradle_build', 'gradle')]);
table.replaceType(RunTaskType.npm, [task('npm_start', 'npm')]);
table.setUserTasks([
const RunTask(id: 'user_1', name: 'custom', command: 'echo', source: TaskSource.custom),
]);
expect(table.tasksOf(RunTaskType.gradle), hasLength(1));
expect(table.tasksOf(RunTaskType.cmake), isEmpty);
expect(table.nonEmptyTypes, [RunTaskType.gradle, RunTaskType.npm, RunTaskType.user]);
expect(RunTaskType.ofTask(table.allOrdered.last), RunTaskType.user);
expect(table.detectedTasks.any((t) => t.source == TaskSource.custom), isFalse);
// 覆盖写入(重新同步)不会残留旧任务
table.replaceType(RunTaskType.gradle, [task('gradle_test', 'gradle')]);
expect(table.tasksOf(RunTaskType.gradle).map((t) => t.id), ['gradle_test']);
});
});
}
+281
View File
@@ -0,0 +1,281 @@
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:path/path.dart' as p;
import 'package:code_editor/models/run_task.dart';
import 'package:code_editor/models/run_task_type.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';
/// 计数用存储服务:用于验证"用户探测"的并发合并(磁盘 IO 不被放大)
class _CountingStorage extends RunTaskStorageService {
int loadCount = 0;
@override
Future<({List<RunTask> tasks, String? lastRunTaskId})> loadConfig(String projectRoot) {
loadCount++;
return super.loadConfig(projectRoot);
}
}
/// 固定返回任务的假系统模块
class _StubModule extends ProjectModule {
@override
final String id;
@override
final String displayName;
final List<RunTask> tasks;
_StubModule(this.id, this.tasks, {String? displayName}) : displayName = displayName ?? id;
@override
List<String> get triggerFiles => const [];
@override
bool shouldActivate(Directory projectDir) => true;
@override
Future<ModuleProbeResult> probe(ProjectProbe probe) async => ModuleProbeResult.ok(id, tasks);
}
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
const systemName = 'test_sys';
late Directory projectDir;
late Directory distroBaseDir;
late DistroManager distroManager;
setUp(() async {
projectDir = await Directory.systemTemp.createTemp('probe_split_project_');
distroBaseDir = await Directory.systemTemp.createTemp('probe_split_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;
if (await projectDir.exists()) await projectDir.delete(recursive: true);
if (await distroBaseDir.exists()) await distroBaseDir.delete(recursive: true);
});
RunTask task(String id, String moduleId) => RunTask(
id: id,
name: id,
command: 'echo $id',
source: TaskSource.detected,
moduleId: moduleId,
);
RunProvider buildProvider(RunTaskStorageService storage, {ProjectTaskDispatcher? dispatcher}) {
return RunProvider(
storageService: storage,
dispatcher: dispatcher ?? ProjectTaskDispatcher(customModules: [_StubModule('gradle', [task('gradle_build', 'gradle')])]),
distroManager: distroManager,
);
}
group('探测层三函数:探测 / 系统探测 / 用户探测', () {
test('探测函数:清空内存 → 用户探测(磁盘覆盖内存)→ 系统探测(模块写入类型格)', () async {
final storage = RunTaskStorageService();
// 磁盘上先放一份用户任务与"上次执行"
const userTask = RunTask(
id: 'user_1',
name: '我的任务',
command: 'echo user',
source: TaskSource.custom,
);
await storage.saveConfig(projectRoot: projectDir.path, tasks: [userTask], lastRunTaskId: 'user_1');
final provider = buildProvider(storage);
// 先手动污染内存中的用户任务,验证"覆盖"语义
await provider.probeUser(projectRoot: projectDir.path);
expect(provider.customTasks.map((t) => t.id), ['user_1']);
await provider.probeProject(
projectRoot: projectDir.path,
systemName: systemName,
);
// 用户探测从磁盘覆盖
expect(provider.customTasks.map((t) => t.id), ['user_1']);
expect(provider.lastRunTaskId, 'user_1');
expect(provider.lastRunTask?.id, 'user_1');
// 系统探测写入 gradle 类型格
expect(provider.taskTable.tasksOf(RunTaskType.gradle).map((t) => t.id), ['gradle_build']);
expect(provider.taskTable.tasksOf(RunTaskType.user).map((t) => t.id), ['user_1']);
expect(provider.isDetecting, isFalse);
});
test('探测函数会清空上一轮系统任务(系统任务只存在于内存)', () async {
final storage = RunTaskStorageService();
final dispatcher = ProjectTaskDispatcher(customModules: [
_StubModule('gradle', [task('gradle_a', 'gradle')]),
]);
final provider = buildProvider(storage, dispatcher: dispatcher);
await provider.probeProject(projectRoot: projectDir.path, systemName: systemName);
expect(provider.taskTable.tasksOf(RunTaskType.gradle).map((t) => t.id), ['gradle_a']);
// 换成"探测不出任何任务"的模块后重新探测 -> 旧的系统任务必须被清掉
final emptyDispatcher = ProjectTaskDispatcher(customModules: [
_StubModule('gradle', const []),
]);
final provider2 = RunProvider(
storageService: storage,
dispatcher: emptyDispatcher,
distroManager: distroManager,
);
await provider2.probeProject(projectRoot: projectDir.path, systemName: systemName);
expect(provider2.detectedTasks, isEmpty);
});
test('无可用系统时只完成用户探测,系统类型格保持为空', () async {
final storage = RunTaskStorageService();
await storage.saveConfig(
projectRoot: projectDir.path,
tasks: [
const RunTask(id: 'user_1', name: 'u', command: 'echo', source: TaskSource.custom),
],
);
final provider = buildProvider(storage);
await provider.probeProject(projectRoot: projectDir.path, systemName: null);
expect(provider.customTasks, hasLength(1));
expect(provider.detectedTasks, isEmpty);
});
test('用户探测并发合并:连续 50 次触发只做 1~2 次磁盘读取,且最后一次编辑生效', () async {
final storage = _CountingStorage();
final provider = buildProvider(storage);
const finalTask = RunTask(
id: 'user_final',
name: 'final',
command: 'echo',
source: TaskSource.custom,
);
await storage.saveConfig(projectRoot: projectDir.path, tasks: [finalTask]);
// 模拟"用户瞬间编辑了几十次":紧循环触发(两次调用之间不 await,才能形成真正的并发重叠)
final futures = <Future<void>>[];
for (var i = 0; i < 50; i++) {
futures.add(provider.probeUser(projectRoot: projectDir.path));
}
await Future.wait(futures);
// 合并后可能还有一次补跑,多等一拍
await Future<void>.delayed(const Duration(milliseconds: 50));
expect(storage.loadCount, lessThanOrEqualTo(2),
reason: '并发合并应把 50 次触发压缩为 1~2 次磁盘读取');
// 内存中的用户任务等于磁盘上的最终内容(覆盖语义)
expect(provider.customTasks.map((t) => t.id), ['user_final']);
});
test('编辑用户任务:先写盘再用户探测,内存 user 格被磁盘内容覆盖', () async {
final storage = RunTaskStorageService();
final provider = buildProvider(storage);
await provider.probeProject(projectRoot: projectDir.path, systemName: systemName);
const edited = RunTask(
id: 'user_custom_1',
name: 'My Custom Run',
command: 'echo "custom"',
source: TaskSource.custom,
);
await provider.addCustomTask(edited);
expect(provider.customTasks.any((t) => t.id == 'user_custom_1'), isTrue);
// 直接从磁盘读回的持久化结果应与内存一致
final persisted = await storage.loadConfig(projectDir.path);
expect(persisted.tasks.map((t) => t.id), ['user_custom_1']);
});
test('"上一次执行任务"同样走磁盘并同步内存(任务被删除时不再命中)', () async {
final storage = RunTaskStorageService();
final provider = buildProvider(storage);
await provider.probeProject(projectRoot: projectDir.path, systemName: systemName);
const userTask = RunTask(
id: 'user_run_me',
name: 'run me',
command: 'echo',
source: TaskSource.custom,
);
await provider.addCustomTask(userTask);
await provider.setLastRunTask(userTask);
expect(provider.lastRunTask?.id, 'user_run_me');
expect((await storage.loadConfig(projectDir.path)).lastRunTaskId, 'user_run_me');
// 删除该任务后再探一次:id 仍在,但内存对象不再命中
await provider.removeCustomTask('user_run_me');
expect(provider.customTasks, isEmpty);
expect(provider.lastRunTask, isNull);
});
test('requestProjectProbe:探测进行中时拒绝并返回 false', () async {
final storage = RunTaskStorageService();
final provider = buildProvider(storage);
// 构造一个"慢模块",让探测保持在 isDetecting 状态
final slowDispatcher = ProjectTaskDispatcher(customModules: [
_SlowModule('gradle'),
]);
final slowProvider = RunProvider(
storageService: storage,
dispatcher: slowDispatcher,
distroManager: distroManager,
);
final running = slowProvider.probeProject(
projectRoot: projectDir.path,
systemName: systemName,
);
await Future<void>.delayed(const Duration(milliseconds: 30));
expect(slowProvider.isDetecting, isTrue);
final started = await slowProvider.requestProjectProbe(
projectRoot: projectDir.path,
systemName: systemName,
);
expect(started, isFalse, reason: '已有探测在进行时应拒绝新的探测请求');
await running;
expect(slowProvider.isDetecting, isFalse);
// 未使用的 provider 不影响断言
expect(provider.isDetecting, isFalse);
});
});
}
/// 慢模块:让探测持续一段时间,便于观察 isDetecting
class _SlowModule extends ProjectModule {
@override
final String id;
_SlowModule(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 {
await Future<void>.delayed(const Duration(milliseconds: 200));
return ModuleProbeResult.ok(id, const []);
}
}
+157 -10
View File
@@ -2,33 +2,59 @@ import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter_localizations/flutter_localizations.dart';
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/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/run_task_storage_service.dart';
import 'package:code_editor/services/project_task_detector.dart';
import 'package:code_editor/services/project_task_dispatcher.dart';
import 'package:code_editor/widgets/notice_host.dart';
import 'package:code_editor/widgets/run_tasks_dialog.dart';
/// 单测用的假系统名(探测必须基于"真实可用系统",单测里用假 rootfs 代替真容器)
const String kTestSystemName = 'test_sys';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
group('RunTask & RunTaskStorageService Tests', () {
late Directory tempDir;
late RunTaskStorageService storageService;
late Directory distroBaseDir;
late DistroManager distroManager;
setUp(() async {
tempDir = await Directory.systemTemp.createTemp('run_task_test_');
storageService = RunTaskStorageService();
// 构造一个已安装就绪的假系统:<base>/<sys>/rootfs/{etc,bin}
// 并放入各模块所需工具链的桩文件(依赖检测走宿主 rootfs 快速判定)
distroBaseDir = await Directory.systemTemp.createTemp('run_task_distro_');
final rootfs = Directory(p.join(distroBaseDir.path, kTestSystemName, 'rootfs'));
Directory(p.join(rootfs.path, 'etc')).createSync(recursive: true);
Directory(p.join(rootfs.path, 'bin')).createSync(recursive: true);
final usrBin = Directory(p.join(rootfs.path, 'usr', 'bin'))..createSync(recursive: true);
for (final binary in ['java', 'gradle', 'cmake', 'make', 'npm', 'node', 'cargo']) {
File(p.join(usrBin.path, binary)).writeAsStringSync('#!/bin/sh\n');
}
distroManager = DistroManager()..customBaseDir = distroBaseDir;
});
tearDown(() async {
DistroManager().customBaseDir = null;
if (await tempDir.exists()) {
await tempDir.delete(recursive: true);
}
if (await distroBaseDir.exists()) {
await distroBaseDir.delete(recursive: true);
}
});
test('save and load custom tasks', () async {
final initialTasks = await storageService.loadTasks(tempDir.path);
final initialTasks = (await storageService.loadConfig(tempDir.path)).tasks;
expect(initialTasks, isEmpty);
final customTask = const RunTask(
@@ -40,9 +66,9 @@ void main() {
clearBeforeRun: true,
);
await storageService.saveTasks(tempDir.path, [customTask]);
await storageService.saveConfig(projectRoot: tempDir.path, tasks: [customTask]);
final loadedTasks = await storageService.loadTasks(tempDir.path);
final loadedTasks = (await storageService.loadConfig(tempDir.path)).tasks;
expect(loadedTasks.length, 1);
expect(loadedTasks.first.id, 'task_1');
expect(loadedTasks.first.name, 'Debug Build');
@@ -60,7 +86,7 @@ void main() {
expect(config.tasks.length, 1);
});
test('ProjectTaskDetector detects CMake and single file', () async {
test('任务探测:CMake + 单文件任务', () async {
// 模拟 CMakeLists.txt
final cmakeFile = File('${tempDir.path}/CMakeLists.txt');
await cmakeFile.writeAsString('cmake_minimum_required(VERSION 3.10)');
@@ -69,9 +95,11 @@ void main() {
final pyFile = File('${tempDir.path}/main.py');
await pyFile.writeAsString('print("hello")');
final tasks = await ProjectTaskDetector.detect(
final tasks = await ProjectTaskDispatcher.instance.detect(
projectRoot: tempDir.path,
currentFilePath: pyFile.path,
systemName: kTestSystemName,
distroManager: distroManager,
);
expect(tasks.isNotEmpty, isTrue);
@@ -84,7 +112,7 @@ void main() {
expect(tasks.any((t) => t.id == 'detected_cmake_clean'), isTrue);
});
test('ProjectTaskDetector detects Makefile, Gradle, Cargo, NPM, Dart and source files', () async {
test('任务探测:Makefile / Cargo / NPM / Dart / 单文件(Gradle 只认真实自省)', () async {
final makefile = File('${tempDir.path}/Makefile');
await makefile.writeAsString('all:\n\tgcc main.c\n');
@@ -92,7 +120,7 @@ void main() {
await cargoToml.writeAsString('[package]\nname = "demo"\n');
final packageJson = File('${tempDir.path}/package.json');
await packageJson.writeAsString('{"name": "demo"}');
await packageJson.writeAsString('{"name": "demo", "scripts": {"start": "node index.js", "test": "jest"}}');
final pubspec = File('${tempDir.path}/pubspec.yaml');
await pubspec.writeAsString('name: demo\n');
@@ -103,9 +131,11 @@ void main() {
final cppFile = File('${tempDir.path}/main.cpp');
await cppFile.writeAsString('int main() { return 0; }');
final tasks = await ProjectTaskDetector.detect(
final tasks = await ProjectTaskDispatcher.instance.detect(
projectRoot: tempDir.path,
currentFilePath: cppFile.path,
systemName: kTestSystemName,
distroManager: distroManager,
);
expect(tasks.any((t) => t.id == 'detected_single_cpp'), isTrue);
@@ -114,7 +144,10 @@ void main() {
expect(tasks.any((t) => t.id == 'detected_cargo_run'), isTrue);
expect(tasks.any((t) => t.id == 'detected_npm_start'), isTrue);
expect(tasks.any((t) => t.id == 'detected_dart_run'), isTrue);
expect(tasks.any((t) => t.id == 'detected_gradle_run'), isTrue);
// Gradle 只认真实自省结果:测试环境无法真正执行 gradle,因此不产出任何 Gradle 任务,
// 更不允许出现任何硬编码兜底任务(detected_gradle_*)
expect(tasks.any((t) => t.id.startsWith('detected_gradle_')), isFalse);
expect(tasks.any((t) => t.moduleId == 'gradle'), isFalse);
});
});
@@ -407,6 +440,120 @@ void main() {
expect(runProvider.lastRunTaskId, isNull);
expect(runProvider.allTasks, isEmpty);
});
testWidgets('RunTasksDialog: 任务类型折叠 Tile 自由切换且在内存中保持折叠状态', (tester) async {
const detectedTasks = [
RunTask(
id: 'detected_gradle_run',
name: 'Gradle: Run',
command: 'sh ./gradlew run',
source: TaskSource.detected,
moduleId: 'gradle',
group: 'mod development/internal',
),
];
Widget buildDialog() {
return MaterialApp(
localizationsDelegates: const [
AppLocalizations.delegate,
GlobalMaterialLocalizations.delegate,
GlobalWidgetsLocalizations.delegate,
GlobalCupertinoLocalizations.delegate,
],
supportedLocales: const [Locale('zh'), Locale('en')],
locale: const Locale('zh'),
home: Scaffold(
body: RunTasksDialog(
customTasks: const [],
detectedTasks: detectedTasks,
onTaskSelected: (_) {},
onEditCustomTasks: () {},
),
),
);
}
// 1. 初次渲染,任务正常显示
await tester.pumpWidget(buildDialog());
await tester.pumpAndSettle();
expect(find.text('Gradle: Run'), findsOneWidget);
// 2. 点击 Gradle 折叠 tile 头部将其收起
await tester.tap(find.text('Gradle'));
await tester.pumpAndSettle();
expect(find.text('Gradle: Run'), findsNothing);
// 3. 模拟关闭并重新打开 Dialog(重建 widget)
await tester.pumpWidget(buildDialog());
await tester.pumpAndSettle();
// 折叠状态由内存持久化维持,依然处于收起状态
expect(find.text('Gradle: Run'), findsNothing);
// 4. 再次点击重新展开
await tester.tap(find.text('Gradle'));
await tester.pumpAndSettle();
expect(find.text('Gradle: Run'), findsOneWidget);
});
testWidgets('NoticeHost 卡片视觉:成功时背景为绿色,失败时为红色描边', (tester) async {
final center = NoticeCenter();
await tester.pumpWidget(
MaterialApp(
localizationsDelegates: const [
AppLocalizations.delegate,
GlobalMaterialLocalizations.delegate,
GlobalWidgetsLocalizations.delegate,
GlobalCupertinoLocalizations.delegate,
],
supportedLocales: const [Locale('zh'), Locale('en')],
locale: const Locale('zh'),
home: Scaffold(
body: NoticeHost(center: center),
),
),
);
// 1. 推送成功通知
center.push(const NoticeItem(
id: 'success_notice',
kind: NoticeKind.success,
text: ModuleDoneText('Gradle', taskCount: 3),
));
await tester.pumpAndSettle();
final successMaterial = tester.widget<Material>(
find.ancestor(
of: find.textContaining('Gradle'),
matching: find.byType(Material),
).first,
);
// 成功卡片背景为深绿或绿色
expect(successMaterial.color, equals(const Color(0xFF2E7D32)));
// 2. 推送失败通知
center.push(const NoticeItem(
id: 'failure_notice',
kind: NoticeKind.failure,
text: ModuleFailureText(
moduleDisplayName: 'CMake',
failure: NoticeFailure.executionFailed,
),
));
await tester.pumpAndSettle();
final failureMaterial = tester.widget<Material>(
find.ancestor(
of: find.textContaining('CMake'),
matching: find.byType(Material),
).first,
);
final shape = failureMaterial.shape as RoundedRectangleBorder;
// 失败卡片有红色描边
expect(shape.side.color, equals(const Color(0xFFE53935)));
expect(shape.side.width, equals(1.5));
});
});
}
+79
View File
@@ -0,0 +1,79 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:code_editor/l10n/app_localizations.dart';
import 'package:code_editor/widgets/terminal_entry_guard.dart';
void main() {
TestWidgetsFlutterBinding.ensureInitialized();
/// 挂一个按钮调用守卫,把返回值记录下来(无需真正进入终端 view)
Future<void> pumpGuard(WidgetTester tester, List<bool> results) async {
await tester.pumpWidget(
MaterialApp(
locale: const Locale('zh'),
localizationsDelegates: AppLocalizations.localizationsDelegates,
supportedLocales: AppLocalizations.supportedLocales,
home: Scaffold(
body: Builder(
builder: (context) => Center(
child: ElevatedButton(
onPressed: () async {
results.add(await confirmEnterTerminalWhileProbing(context));
},
child: const Text('terminal'),
),
),
),
),
),
);
await tester.pumpAndSettle();
}
group('进入终端前的探测占用确认', () {
testWidgets('文案与按钮来自 l10n,取消 => 不进入终端', (tester) async {
final results = <bool>[];
await pumpGuard(tester, results);
await tester.tap(find.text('terminal'));
await tester.pumpAndSettle();
expect(find.text('任务探测进行中'), findsOneWidget);
expect(find.textContaining('是否仍要进入终端?'), findsOneWidget);
expect(find.text('继续进入终端'), findsOneWidget);
await tester.tap(find.text('取消'));
await tester.pumpAndSettle();
expect(results, [false], reason: '取消必须返回 false(不进入终端)');
});
testWidgets('继续进入终端 => 返回 true', (tester) async {
final results = <bool>[];
await pumpGuard(tester, results);
await tester.tap(find.text('terminal'));
await tester.pumpAndSettle();
await tester.tap(find.text('继续进入终端'));
await tester.pumpAndSettle();
expect(results, [true]);
});
testWidgets('点弹窗外部关闭 => 按取消处理(保守不进入)', (tester) async {
final results = <bool>[];
await pumpGuard(tester, results);
await tester.tap(find.text('terminal'));
await tester.pumpAndSettle();
// 点击对话框外的遮罩区域
await tester.tapAt(const Offset(10, 10));
await tester.pumpAndSettle();
expect(results, [false]);
});
});
}
@@ -1,11 +1,9 @@
import 'dart:ui';
import 'package:code_editor/l10n/app_localizations.dart';
import 'package:code_editor/models/terminal_session.dart';
import 'package:code_editor/providers/settings_provider.dart';
import 'package:code_editor/providers/terminal_provider.dart';
import 'package:code_editor/views/settings_view.dart';
import 'package:code_editor/views/terminal_view.dart';
import 'package:flutter/gestures.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
@@ -277,6 +275,7 @@ void main() {
expect(termView.controller?.selection, isNotNull);
expect(termView.controller?.selection!.isCollapsed, isFalse);
expect(textInputShowCount, 0, reason: 'Long press must not show soft keyboard');
expect(textInputAttachCount, greaterThanOrEqualTo(0));
// 3. Lift finger: Floating menu (复制, 粘贴, 全选) should appear
await gesture.up();
+57
View File
@@ -1,4 +1,5 @@
import 'dart:io';
import 'dart:ui';
import 'package:re_editor/re_editor.dart';
import 'package:code_editor/models/app_font.dart';
import 'package:code_editor/models/editor_tab_item.dart';
@@ -3638,6 +3639,62 @@ void main() {
expect(scrollController.horizontalScroller.offset, 50.0);
});
testWidgets('CodeEditor continuous bidirectional gesture scrolls horizontally then vertically without lifting finger', (tester) async {
final text = List.generate(50, (i) => 'Line $i: const aLongVariableNameThatIsVeryLong = 1234567890 + 987654321;').join('\n');
final controller = CodeLineEditingController.fromText(text);
final scrollController = CodeScrollController();
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: SizedBox(
width: 300,
height: 400,
child: CodeEditor(
controller: controller,
scrollController: scrollController,
wordWrap: false,
pinLineNumbers: false,
),
),
),
),
);
await tester.pumpAndSettle();
expect(scrollController.horizontalScroller.offset, 0.0);
expect(scrollController.verticalScroller.offset, 0.0);
// Start drag gesture with touch
final gesture = await tester.startGesture(const Offset(200, 200), kind: PointerDeviceKind.touch);
// Exceed touch slop to trigger onStart
await gesture.moveBy(const Offset(-30, 0));
// Subsequent movement triggers onUpdate
await gesture.moveBy(const Offset(-60, 0));
await tester.pump();
expect(scrollController.horizontalScroller.offset, greaterThan(0.0));
final hOffsetAfterHorizontal = scrollController.horizontalScroller.offset;
// Now scroll vertically without lifting finger
await gesture.moveBy(const Offset(0, -60));
await tester.pump();
expect(scrollController.verticalScroller.offset, greaterThan(0.0));
// Horizontal offset should still be preserved
expect(scrollController.horizontalScroller.offset, closeTo(hOffsetAfterHorizontal, 1.0));
// Diagonal movement scrolls both
await gesture.moveBy(const Offset(-30, -30));
await tester.pump();
expect(scrollController.horizontalScroller.offset, greaterThan(hOffsetAfterHorizontal));
expect(scrollController.verticalScroller.offset, greaterThan(50.0));
await gesture.up();
await tester.pumpAndSettle();
});
});
}