merge(app): land schedule-seed

This commit is contained in:
2026-10-22 17:47:35 +01:00
6 changed files with 715 additions and 3 deletions
@@ -2,6 +2,7 @@ import 'package:flutter/widgets.dart';
import '../../../core/api_gateway.dart';
import '../../artifacts/ui/artifact_gallery_action.dart';
import '../../schedules/ui/run/schedule_run_action.dart';
import '../actions/cancel_eligibility.dart';
import '../actions/cancel_run_action.dart';
import '../actions/retry_action.dart';
@@ -46,6 +47,8 @@ class RunDetailActions extends StatelessWidget {
gateway: gateway,
onRunChanged: onRunChanged,
),
if (canScheduleRun(run))
ScheduleRunAction(run: run, gateway: gateway),
if (retryRunId(run) != null && canRetryRun(run))
RetryRunAction(
run: run,
@@ -1,5 +1,6 @@
import '../../../../core/api_gateway.dart';
import '../saved_schedule.dart';
import '../schedule_json.dart';
import '../schedule_rule.dart';
/// Which half of the timer rule the editor is writing.
@@ -43,6 +44,18 @@ class ScheduleDraft {
String timezone = '';
String notifyMode = 'auto';
/// Advanced run options the editor does not render yet. A create from a run
/// seeds them from that run and an edit seeds them from the saved record, so
/// [build] always saves the run's original configuration instead of silently
/// dropping it.
String model = '';
JsonMap stageModels = <String, dynamic>{};
List<String> writePaths = [];
bool allowTools = false;
JsonMap otherInput = <String, dynamic>{};
String title = '';
String outputFormat = '';
/// New schedule: the server's create sentinel is `id: 0` with no revision.
factory ScheduleDraft.create({
required int pipelineId,
@@ -54,6 +67,31 @@ class ScheduleDraft {
..workspace = workspace
..timezone = timezone;
/// New schedule seeded from one recorded run, mirroring `scheduleDraft({
/// run })` in `web/src/schedules.js`: the run's title, prompt, pinned version,
/// absolute workspace, notification mode and advanced run options are copied.
/// Every input key survives with `prompt` kept as the editable field; the
/// schedule `title` follows the browser's `title_source` rule. Timer,
/// weekday and timezone fields keep the create defaults (an empty timezone
/// means the server's zone), and nothing is sent until the editor is saved.
factory ScheduleDraft.fromRun(JsonMap run) {
final input = run['input'];
final notifyMode = run['notify_mode'];
return ScheduleDraft._(null, jsonInteger(run['pipeline_id']))
..name = jsonText(run['title'])
..prompt = jsonText(input is Map ? input['prompt'] : null)
..version = _runVersion(run['version'])
..workspace = jsonText(run['workspace'])
..notifyMode = notifyMode is String ? notifyMode : 'auto'
..model = jsonText(run['model'])
..stageModels = _jsonObject(run['stage_models'])
..writePaths = _jsonTexts(run['write_paths'])
..allowTools = run['allow_tools'] == true
..otherInput = _inputExceptPrompt(input)
..title = _runScheduleTitle(run)
..outputFormat = jsonText(run['output_format']);
}
/// Existing record: every field starts from the server value, never from a
/// default that could overwrite it.
factory ScheduleDraft.fromSchedule(SavedSchedule s, {int? pipelineId}) {
@@ -71,7 +109,14 @@ class ScheduleDraft {
..times = rule.times.join(', ')
..days = [...rule.days]
..timezone = rule.timezone
..notifyMode = s.raw['notify_mode'] is String ? s.notifyMode : 'auto';
..notifyMode = s.raw['notify_mode'] is String ? s.notifyMode : 'auto'
..model = s.model
..stageModels = _jsonObject(s.raw['stage_models'])
..writePaths = s.writePaths
..allowTools = s.allowTools
..otherInput = _inputExceptPrompt(s.input)
..title = s.title
..outputFormat = s.outputFormat;
}
/// Validates every field and assembles the exact `save_schedule` record.
@@ -138,8 +183,11 @@ class ScheduleDraft {
record['pipeline_id'] = selectedPipeline;
record['version'] = pinned;
record['enabled'] = enabled;
record['input'] = (source?.input ?? <String, dynamic>{})
..['prompt'] = prompt;
// Every run/record input key survives; only the editable prompt is replaced.
record['input'] = <String, dynamic>{
...cloneJsonMap(otherInput),
'prompt': prompt,
};
// Untrimmed like `workspace: draft.workspace`; validation also runs on the
// untrimmed value, so a valid workspace is sent exactly as the operator
// entered it.
@@ -163,6 +211,38 @@ class ScheduleDraft {
if (timezone.trim().isNotEmpty) rule['timezone'] = timezone.trim();
record['rule'] = rule;
record['notify_mode'] = notifyMode;
// Advanced options follow `serializeSchedule`: an empty value removes the
// key so a create stays minimal and an edit drops what the operator cleared.
if (writePaths.isNotEmpty) {
record['write_paths'] = [...writePaths];
} else {
record.remove('write_paths');
}
if (allowTools) {
record['allow_tools'] = true;
} else {
record.remove('allow_tools');
}
if (model.isNotEmpty) {
record['model'] = model;
} else {
record.remove('model');
}
if (stageModels.isNotEmpty) {
record['stage_models'] = cloneJsonMap(stageModels);
} else {
record.remove('stage_models');
}
if (title.isNotEmpty) {
record['title'] = title;
} else {
record.remove('title');
}
if (outputFormat.isNotEmpty) {
record['output_format'] = outputFormat;
} else {
record.remove('output_format');
}
return ScheduleSaveResult(record, const {});
}
}
@@ -170,6 +250,52 @@ class ScheduleDraft {
const _maxSafeInteger = 9007199254740991;
bool _validIdentity(int? value) =>
value != null && value > 0 && value <= _maxSafeInteger;
/// A run input with `prompt` removed, deep-copied so the draft never aliases the
/// reply map. Build re-adds the editable prompt.
JsonMap _inputExceptPrompt(dynamic input) {
if (input is! Map) return <String, dynamic>{};
return <String, dynamic>{
for (final entry in input.entries)
if ('${entry.key}' != 'prompt')
'${entry.key}': cloneJsonValue(entry.value),
};
}
/// Deep-copied JSON object for `stage_models`; a non-object field is empty.
JsonMap _jsonObject(dynamic value) {
if (value is! Map) return <String, dynamic>{};
return <String, dynamic>{
for (final entry in value.entries)
'${entry.key}': cloneJsonValue(entry.value),
};
}
List<String> _jsonTexts(dynamic value) => value is List
? [
for (final item in value)
if (item is String) item,
]
: const [];
/// Renders like the browser's `String(run.version)`: a number keeps its exact
/// text (an integral one without a `.0`), while a malformed value stays visible
/// so the editor's own check explains it.
String _runVersion(dynamic value) => switch (value) {
String() => value,
num() when value.isFinite => (jsonInteger(value) ?? value).toString(),
_ => '',
};
/// The schedule `title` seeded from a run, mirroring `scheduleDraft({ run })`:
/// a generated or fallback run title is not copied, while an explicit/operator
/// title (or a run that does not report its source) is.
String _runScheduleTitle(JsonMap run) {
final source = jsonText(run['title_source']);
if (source.isNotEmpty && source != 'explicit' && source != 'user') return '';
return jsonText(run['title']);
}
final _digits = RegExp(r'^\d+$');
final _timeOfDay = RegExp(r'^([01]\d|2[0-3]):[0-5]\d$');
final _workspaceBreaks = RegExp(r'[\x00\r\n]');
@@ -20,3 +20,24 @@ dynamic cloneJsonValue(dynamic value) {
JsonMap cloneJsonMap(JsonMap value) =>
Map<String, dynamic>.from(cloneJsonValue(value) as Map);
/// Whole number from a decoded JSON field, as the browser's `Number(value)`
/// followed by an integer check: integral numbers and integral numeric strings
/// are accepted; null, fractions, non-finite values and non-numeric text are
/// not.
int? jsonInteger(dynamic value) {
if (value is int) return value;
if (value is num) {
if (!value.isFinite || value != value.truncateToDouble()) return null;
return value.toInt();
}
if (value is String) {
final number = num.tryParse(value.trim());
if (number == null || !number.isFinite) return null;
return number == number.truncateToDouble() ? number.toInt() : null;
}
return null;
}
/// String field from a decoded JSON value; anything else is the empty string.
String jsonText(dynamic value) => value is String ? value : '';
@@ -0,0 +1,86 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../../../core/api_gateway.dart';
import '../../../../ui/adaptive/host.dart';
import '../../data/schedules_repository.dart';
import '../../domain/editor/schedule_draft.dart';
import '../../domain/schedule_json.dart';
import '../pipeline/schedule_pipeline_editor.dart';
/// Browser wording for the run detail's independent schedule entry point.
const scheduleRunActionLabel = 'Schedule this run';
const scheduleRunActionHint =
'Save this run\'s prompt and options with an independent timer; '
'does not rerun it now';
const scheduleRunActionKey = ValueKey<String>('schedule-run-action');
/// Whether [run] names the positive pipeline and pinned version the web client
/// requires before offering "Schedule this run" (`Number(...) > 0`).
bool canScheduleRun(JsonMap run) =>
_positive(jsonInteger(run['pipeline_id'])) &&
_positive(jsonInteger(run['version']));
bool _positive(int? value) => value != null && value > 0;
/// The run detail's "Schedule this run" action.
///
/// Pressing it only opens the landed create editor over [ScheduleDraft.fromRun]:
/// the run's prompt, title, pinned version, absolute workspace, notification
/// mode and advanced options are prefilled and nothing is sent until Save. One
/// request key is minted per opening and captured by the submit callback, so
/// retrying a refused save cannot create a duplicate. An accepted save closes
/// the editor; this action never runs, retries or changes the source run.
class ScheduleRunAction extends StatefulWidget {
const ScheduleRunAction({
super.key,
required this.run,
required this.gateway,
});
final JsonMap run;
final ApiGateway gateway;
@override
State<ScheduleRunAction> createState() => _ScheduleRunActionState();
}
class _ScheduleRunActionState extends State<ScheduleRunAction> {
bool _opening = false;
Future<void> _open() async {
if (_opening || !canScheduleRun(widget.run)) return;
_opening = true;
// Minted once for this editor; every retry inside it reuses the key.
final requestKey = newScheduleCreateRequestKey();
final repository = SchedulesRepository(widget.gateway);
try {
await openSchedulePipelineEditor(
context,
draft: ScheduleDraft.fromRun(widget.run),
onSubmit: (record) =>
repository.saveSchedule(record, requestKey: requestKey),
);
} finally {
_opening = false;
}
}
@override
Widget build(BuildContext context) {
if (!canScheduleRun(widget.run)) return const SizedBox.shrink();
final cupertino = usesCupertinoHost(context);
final action = cupertino
? CupertinoButton(
key: scheduleRunActionKey,
onPressed: _open,
child: const Text(scheduleRunActionLabel),
)
: OutlinedButton(
key: scheduleRunActionKey,
onPressed: _open,
child: const Text(scheduleRunActionLabel),
);
return Tooltip(message: scheduleRunActionHint, child: action);
}
}
@@ -0,0 +1,214 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/schedules/domain/editor/schedule_draft.dart';
import 'draft_fixtures.dart';
/// A run that exercised every run-level option: extra input keys, a non-auto
/// notification mode, write restrictions, tool access, model overrides, an
/// explicit title and an output format.
JsonMap restrictedRun() => {
'id': 7,
'title': 'Nightly build',
'title_source': 'explicit',
'pipeline_id': 4,
'version': 5,
'input': {
'prompt': ' keep\n\nspacing ',
'topic': 'release notes',
'pwd': '/srv/work',
'nested': {'alpha': 1},
},
'workspace': '/srv/run-workspace',
'rule': {
'every': '2h',
'days': ['mon'],
'timezone': 'Europe/London',
},
'notify_mode': 'off',
'write_paths': ['src/file.go', 'notes'],
'allow_tools': true,
'model': 'provider/model',
'stage_models': {'research': 'provider/other'},
'output_format': 'json',
};
void main() {
test('a run seeds every option the browser copies into a create', () {
final run = restrictedRun();
final snapshot = deepCopy(run);
final draft = ScheduleDraft.fromRun(run);
expect(draft.source, isNull);
expect(draft.pipelineId, 4);
expect(draft.name, 'Nightly build');
expect(draft.prompt, ' keep\n\nspacing ');
expect(draft.version, '5');
expect(draft.workspace, '/srv/run-workspace');
// The run is a prompt snapshot, not a saved timer: create defaults stand.
expect(draft.enabled, isTrue);
expect(draft.mode, ScheduleTimerMode.interval);
expect(draft.every, '24h');
expect(draft.times, '');
expect(draft.days, isEmpty);
expect(draft.timezone, '');
// Run-level options are seeded verbatim.
expect(draft.notifyMode, 'off');
expect(draft.model, 'provider/model');
expect(draft.stageModels, {'research': 'provider/other'});
expect(draft.writePaths, ['src/file.go', 'notes']);
expect(draft.allowTools, isTrue);
expect(draft.title, 'Nightly build');
expect(draft.outputFormat, 'json');
expect(draft.otherInput, {
'topic': 'release notes',
'pwd': '/srv/work',
'nested': {'alpha': 1},
});
final result = draft.build();
expect(result.errors, isEmpty);
expect(result.record, {
'id': 0,
'name': 'Nightly build',
'pipeline_id': 4,
'version': 5,
'enabled': true,
'input': {
'prompt': ' keep\n\nspacing ',
'topic': 'release notes',
'pwd': '/srv/work',
'nested': {'alpha': 1},
},
'workspace': '/srv/run-workspace',
'rule': {'every': '24h'},
'notify_mode': 'off',
'write_paths': ['src/file.go', 'notes'],
'allow_tools': true,
'model': 'provider/model',
'stage_models': {'research': 'provider/other'},
'title': 'Nightly build',
'output_format': 'json',
});
expect(run, snapshot);
});
test('a run without the advanced options still saves a minimal create', () {
final draft = ScheduleDraft.fromRun({
'title': 'Plain run',
'pipeline_id': 4,
'version': 5,
'input': {'prompt': 'P'},
'workspace': '/srv',
});
expect(draft.notifyMode, 'auto');
expect(draft.model, '');
expect(draft.stageModels, isEmpty);
expect(draft.writePaths, isEmpty);
expect(draft.allowTools, isFalse);
expect(draft.otherInput, isEmpty);
expect(draft.title, 'Plain run');
expect(draft.outputFormat, '');
final record = draft.build().record!;
expect(record, {
'id': 0,
'name': 'Plain run',
'pipeline_id': 4,
'version': 5,
'enabled': true,
'input': {'prompt': 'P'},
'workspace': '/srv',
'rule': {'every': '24h'},
'notify_mode': 'auto',
// A run that does not report a title source keeps its title.
'title': 'Plain run',
});
});
test('a generated run title is not copied into the schedule title', () {
for (final source in ['model', 'fallback']) {
final draft = ScheduleDraft.fromRun({
...restrictedRun(),
'title_source': source,
});
// The schedule name still uses the run title, as `scheduleDraft` does.
expect(draft.name, 'Nightly build');
expect(draft.title, '');
expect(draft.build().record!.containsKey('title'), isFalse);
}
for (final source in ['explicit', 'user', null]) {
final run = restrictedRun();
if (source == null) {
run.remove('title_source');
} else {
run['title_source'] = source;
}
expect(ScheduleDraft.fromRun(run).title, 'Nightly build');
}
});
test('a run without pipeline, version, prompt or name stays invalid', () {
final draft = ScheduleDraft.fromRun({
'version': 0,
'input': {'prompt': ''},
});
expect(draft.pipelineId, isNull);
expect(draft.name, '');
expect(draft.prompt, '');
expect(draft.version, '0');
expect(draft.workspace, '');
final result = draft.build();
expect(result.isValid, isFalse);
expect(result.record, isNull);
expect(
result.errors.keys,
containsAll(['pipelineId', 'name', 'prompt', 'version', 'workspace']),
);
});
test('numeric variants render like the browser string and the run is read '
'only', () {
final run = <String, dynamic>{
'title': 'T',
'pipeline_id': 4.0,
'version': 5.0,
'input': {'prompt': 'P'},
'workspace': '/srv',
};
final snapshot = Map<String, dynamic>.from(run);
final draft = ScheduleDraft.fromRun(run);
expect(draft.pipelineId, 4);
expect(draft.version, '5');
expect(draft.build().isValid, isTrue);
expect(run, snapshot);
expect(
ScheduleDraft.fromRun({'pipeline_id': 4, 'version': '6'}).version,
'6',
);
// `String(value)` for a non-integral number, rather than hiding it.
expect(
ScheduleDraft.fromRun({'pipeline_id': '4', 'version': 5.5}).version,
'5.5',
);
});
test('built input never aliases the run map', () {
final run = restrictedRun();
final draft = ScheduleDraft.fromRun(run);
final record = draft.build().record!;
((record['input'] as JsonMap)['nested'] as JsonMap)['extra'] = true;
(record['stage_models'] as JsonMap)['research'] = 'changed';
expect((run['input'] as JsonMap)['nested'], {'alpha': 1});
expect(draft.otherInput['nested'], {'alpha': 1});
expect(draft.stageModels['research'], 'provider/other');
});
}
@@ -0,0 +1,262 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/core/transport/connection_state.dart';
import 'package:pipelines_app/features/runs/ui/run_detail_actions.dart';
import 'package:pipelines_app/features/schedules/ui/editor/schedule_editor_wording.dart';
import 'package:pipelines_app/features/schedules/ui/run/schedule_run_action.dart';
/// Records every `save_schedule` and refuses the first one on demand. No socket
/// or Pipelines server is involved.
class SaveGateway implements ApiGateway {
final calls = <Map<String, dynamic>>[];
bool refuseNext = false;
@override
Stream<JsonMap> get frames => const Stream.empty();
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
if (type != 'save_schedule') throw UnsupportedError('unexpected $type');
calls.add(Map<String, dynamic>.from(fields));
if (refuseNext) {
refuseNext = false;
throw const ProtocolError('conflict: revision 4 is stale');
}
final schedule = Map<String, dynamic>.from(fields['schedule'] as Map);
return {
'type': 'schedule_saved',
'schedule': {...schedule, 'id': 12, 'revision': 1},
};
}
}
JsonMap runFixture({
Object? version = 5,
Object? pipelineId = 4,
String title = 'Nightly build',
String prompt = 'Summarise the release notes.',
String workspace = '/srv/run-workspace',
}) => {
'id': 7,
'title': title,
'pipeline_id': ?pipelineId,
'version': ?version,
'status': 'succeeded',
'input': {
'prompt': prompt,
'nested': {'kept': true},
},
'workspace': workspace,
};
/// A run carrying every option the browser's run seed preserves.
JsonMap restrictedRunFixture() => {
...runFixture(),
'title_source': 'explicit',
'input': {
'prompt': 'Summarise the release notes.',
'topic': 'release notes',
'nested': {'kept': true},
},
'notify_mode': 'off',
'write_paths': ['src/file.go', 'notes'],
'allow_tools': true,
'model': 'provider/model',
'stage_models': {'research': 'provider/other'},
'output_format': 'json',
};
Future<void> pumpAction(
WidgetTester tester,
Widget child, {
bool cupertino = false,
}) async {
tester.view.physicalSize = const Size(390, 1600);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.resetPhysicalSize);
addTearDown(tester.view.resetDevicePixelRatio);
await tester.pumpWidget(
cupertino
? CupertinoApp(
home: CupertinoPageScaffold(child: SafeArea(child: child)),
)
: MaterialApp(
home: Scaffold(body: SafeArea(child: child)),
),
);
await tester.pumpAndSettle();
}
Future<void> tapSave(WidgetTester tester) async {
// A focused field keeps itself visible, so drop focus before scrolling.
FocusManager.instance.primaryFocus?.unfocus();
await tester.pumpAndSettle();
final finder = find.byKey(scheduleEditorSubmitKey);
await tester.ensureVisible(finder);
await tester.pump();
await tester.tap(finder);
await tester.pumpAndSettle();
}
String materialField(WidgetTester tester, Key key) =>
tester.widget<TextField>(find.byKey(key)).controller!.text;
void main() {
testWidgets('opens a create editor seeded from the run without sending', (
tester,
) async {
final gateway = SaveGateway();
await pumpAction(
tester,
ScheduleRunAction(run: runFixture(), gateway: gateway),
);
await tester.tap(find.byKey(scheduleRunActionKey));
await tester.pumpAndSettle();
expect(gateway.calls, isEmpty);
expect(find.text('Add schedule'), findsOneWidget);
expect(materialField(tester, scheduleEditorNameKey), 'Nightly build');
expect(
materialField(tester, scheduleEditorPromptKey),
'Summarise the release notes.',
);
expect(materialField(tester, scheduleEditorVersionKey), '5');
expect(
materialField(tester, scheduleEditorWorkspaceKey),
'/srv/run-workspace',
);
expect(materialField(tester, scheduleEditorEveryKey), '24h');
expect(materialField(tester, scheduleEditorTimezoneKey), '');
expect(gateway.calls, isEmpty);
});
testWidgets('saves the run\'s input, restrictions and overrides once, and '
'reuses the one key after a refusal', (tester) async {
final gateway = SaveGateway()..refuseNext = true;
await pumpAction(
tester,
ScheduleRunAction(run: restrictedRunFixture(), gateway: gateway),
);
await tester.tap(find.byKey(scheduleRunActionKey));
await tester.pumpAndSettle();
await tapSave(tester);
expect(gateway.calls, hasLength(1));
final key = gateway.calls.single['request_key'];
expect(key, isA<String>());
expect(key, isNotEmpty);
expect('$key'.length, lessThanOrEqualTo(128));
expect(
find.textContaining('conflict: revision 4 is stale'),
findsOneWidget,
);
expect(find.textContaining('Your draft is preserved.'), findsOneWidget);
expect(find.byKey(scheduleEditorSubmitKey), findsOneWidget);
expect(
materialField(tester, scheduleEditorPromptKey),
'Summarise the release notes.',
);
await tapSave(tester);
expect(gateway.calls, hasLength(2));
expect(gateway.calls[0]['request_key'], key);
expect(gateway.calls[1]['request_key'], key);
expect(gateway.calls[1]['schedule'], {
'id': 0,
'name': 'Nightly build',
'pipeline_id': 4,
'version': 5,
'enabled': true,
'input': {
'prompt': 'Summarise the release notes.',
'topic': 'release notes',
'nested': {'kept': true},
},
'workspace': '/srv/run-workspace',
'rule': {'every': '24h'},
'notify_mode': 'off',
'write_paths': ['src/file.go', 'notes'],
'allow_tools': true,
'model': 'provider/model',
'stage_models': {'research': 'provider/other'},
'title': 'Nightly build',
'output_format': 'json',
});
expect(find.byKey(scheduleEditorSubmitKey), findsNothing);
});
testWidgets('the action is wired into run detail and hidden without a pin', (
tester,
) async {
final gateway = SaveGateway();
await pumpAction(
tester,
RunDetailActions(
run: runFixture(),
gateway: gateway,
onRunChanged: (_) {},
),
);
expect(find.byKey(scheduleRunActionKey), findsOneWidget);
expect(find.text(scheduleRunActionLabel), findsOneWidget);
await pumpAction(
tester,
RunDetailActions(
run: runFixture(version: 0),
gateway: gateway,
onRunChanged: (_) {},
),
);
expect(find.byKey(scheduleRunActionKey), findsNothing);
await pumpAction(
tester,
RunDetailActions(
run: runFixture(pipelineId: null),
gateway: gateway,
onRunChanged: (_) {},
),
);
expect(find.byKey(scheduleRunActionKey), findsNothing);
});
testWidgets('Cupertino uses the native action and fields', (tester) async {
final gateway = SaveGateway();
await pumpAction(
tester,
ScheduleRunAction(run: runFixture(), gateway: gateway),
cupertino: true,
);
final action = find.byKey(scheduleRunActionKey);
expect(
find.widgetWithText(CupertinoButton, scheduleRunActionLabel),
findsOne,
);
await tester.tap(action);
await tester.pumpAndSettle();
expect(gateway.calls, isEmpty);
expect(find.byKey(scheduleEditorSubmitKey), findsOneWidget);
expect(
tester
.widget<CupertinoTextField>(find.byKey(scheduleEditorVersionKey))
.controller
?.text,
'5',
);
expect(
tester
.widget<CupertinoTextField>(find.byKey(scheduleEditorWorkspaceKey))
.controller
?.text,
'/srv/run-workspace',
);
});
}