132 lines
4.2 KiB
Dart
Raw Normal View History

import 'package:app_flowy/plugins/grid/application/cell/cell_service/cell_service.dart';
import 'package:app_flowy/plugins/grid/application/grid_data_controller.dart';
import 'package:app_flowy/plugins/grid/application/row/row_bloc.dart';
import 'package:app_flowy/plugins/grid/application/row/row_cache.dart';
import 'package:app_flowy/plugins/grid/application/row/row_data_controller.dart';
import 'package:app_flowy/plugins/grid/grid.dart';
import 'package:app_flowy/workspace/application/app/app_service.dart';
import 'package:flowy_sdk/protobuf/flowy-folder/view.pb.dart';
import 'package:flowy_sdk/protobuf/flowy-grid/field_entities.pb.dart';
import '../../util.dart';
/// Create a empty Grid for test
class AppFlowyGridTest {
// ignore: unused_field
final AppFlowyUnitTest _inner;
late ViewPB gridView;
AppFlowyGridTest(AppFlowyUnitTest unitTest) : _inner = unitTest;
static Future<AppFlowyGridTest> ensureInitialized() async {
final inner = await AppFlowyUnitTest.ensureInitialized();
2022-10-23 11:52:15 +08:00
return AppFlowyGridTest(inner);
}
2022-10-23 11:52:15 +08:00
Future<void> createTestGrid() async {
final app = await _inner.createTestApp();
final builder = GridPluginBuilder();
final result = await AppService().createView(
appId: app.id,
name: "Test Grid",
2022-10-22 21:57:44 +08:00
dataFormatType: builder.dataFormatType,
pluginType: builder.pluginType,
layoutType: builder.layoutType!,
);
result.fold(
(view) => gridView = view,
(error) {},
);
}
}
class AppFlowyGridSelectOptionCellTest {
2022-10-23 11:52:15 +08:00
final AppFlowyGridCellTest _gridCellTest;
AppFlowyGridSelectOptionCellTest(AppFlowyGridCellTest cellTest)
2022-10-23 11:52:15 +08:00
: _gridCellTest = cellTest;
static Future<AppFlowyGridSelectOptionCellTest> ensureInitialized() async {
2022-10-23 11:52:15 +08:00
final gridTest = await AppFlowyGridCellTest.ensureInitialized();
return AppFlowyGridSelectOptionCellTest(gridTest);
}
Future<void> createTestGrid() async {
await _gridCellTest.createTestGrid();
}
Future<void> createTestRow() async {
await _gridCellTest.createTestRow();
}
Future<GridSelectOptionCellController> makeCellController(
FieldType fieldType) async {
assert(fieldType == FieldType.SingleSelect ||
fieldType == FieldType.MultiSelect);
final fieldContexts =
2022-10-23 11:52:15 +08:00
_gridCellTest._dataController.fieldController.fieldContexts;
final field =
fieldContexts.firstWhere((element) => element.fieldType == fieldType);
2022-10-23 11:52:15 +08:00
final builder = await _gridCellTest.cellControllerBuilder(field.id);
final cellController = builder.build() as GridSelectOptionCellController;
return cellController;
}
}
2022-10-23 11:52:15 +08:00
/// Create a new Grid for cell test
class AppFlowyGridCellTest {
final AppFlowyGridTest _gridTest;
2022-10-23 11:52:15 +08:00
late GridDataController _dataController;
AppFlowyGridCellTest(AppFlowyGridTest gridTest) : _gridTest = gridTest;
static Future<AppFlowyGridCellTest> ensureInitialized() async {
final gridTest = await AppFlowyGridTest.ensureInitialized();
2022-10-23 11:52:15 +08:00
return AppFlowyGridCellTest(gridTest);
}
Future<void> createTestRow() async {
await _dataController.createRow();
}
2022-10-23 11:52:15 +08:00
Future<void> createTestGrid() async {
await _gridTest.createTestGrid();
_dataController = GridDataController(view: _gridTest.gridView);
final result = await _dataController.loadData();
result.fold((l) => null, (r) => throw Exception(r));
}
Future<GridCellControllerBuilder> cellControllerBuilder(
2022-10-23 11:52:15 +08:00
String fieldId,
) async {
final RowInfo rowInfo = _dataController.rowInfos.last;
final blockCache = _dataController.blocks[rowInfo.rowPB.blockId];
final rowCache = blockCache?.rowCache;
final rowDataController = GridRowDataController(
rowInfo: rowInfo,
fieldController: _dataController.fieldController,
rowCache: rowCache!,
);
final rowBloc = RowBloc(
rowInfo: rowInfo,
dataController: rowDataController,
)..add(const RowEvent.initial());
2022-10-23 10:59:53 +08:00
await gridResponseFuture();
return GridCellControllerBuilder(
cellId: rowBloc.state.gridCellMap[fieldId]!,
cellCache: rowCache.cellCache,
delegate: rowDataController,
);
}
}
2022-10-23 10:59:53 +08:00
Future<void> gridResponseFuture() {
2022-10-23 11:52:15 +08:00
return Future.delayed(gridResponseDuration(milliseconds: 200));
}
2022-10-23 11:52:15 +08:00
Duration gridResponseDuration({int milliseconds = 200}) {
return Duration(milliseconds: milliseconds);
}