From 988834ba37c07015c41a98c2ad5886cf5393f591 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Thu, 22 Oct 2026 03:35:43 +0100 Subject: [PATCH] feat(app): parse and emit the web client's route vocabulary Widen AppRoute to the pipeline detail, definition stage pane, runs filter, run stage pane, decision prompt and template detail the web client already addresses, and canonicalise the /settings/templates aliases. The URL codec moves to app_route_codec.dart as a part file to keep the route model and the parser under the app's 250-line aim. --- app/lib/application/app_route.dart | 196 ++++++++++++++------- app/lib/application/app_route_codec.dart | 214 +++++++++++++++++++++++ app/test/application/app_route_test.dart | 182 ++++++++++++++++++- 3 files changed, 519 insertions(+), 73 deletions(-) create mode 100644 app/lib/application/app_route_codec.dart diff --git a/app/lib/application/app_route.dart b/app/lib/application/app_route.dart index b0e51f2f..144796a7 100644 --- a/app/lib/application/app_route.dart +++ b/app/lib/application/app_route.dart @@ -1,16 +1,45 @@ +part 'app_route_codec.dart'; + /// The destinations the app has a URL for. /// /// The set mirrors [AppDestination] but stays free of widget imports so the /// parser and serialiser can be exercised without a Flutter host. enum AppRouteKind { pipelines, runs, chat, search, settings, templates } -/// One page route: a destination plus the run it opens, if any. +/// One page route: a destination plus the detail, pane and query it opens. /// -/// Parsing is total, like the web client's route model: an unknown or -/// malformed path resolves to the default Pipelines list instead of throwing. -/// The serialiser is its inverse for every route the app can produce. +/// The URL vocabulary mirrors `web/src/routes.js`: +/// +/// /pipelines Pipelines list +/// /pipelines/:id pipeline detail, latest version +/// /pipelines/:id/:version pipeline detail at a version +/// /pipelines/:id[/:version]/stage/:key definition stage pane +/// /runs Runs list (optional ?pipeline=) +/// /runs/:id run detail (optional ?action=decide) +/// /runs/:id/stage/:key[?visit=N] one visit's stage pane +/// /templates[/:key] template gallery / detail +/// /settings/templates[/:key] aliases for the template routes +/// /chat[/:id], /search, /settings unchanged destinations +/// +/// Only the two stage panes are deep-linkable; other in-page state stays out +/// of the URL. Unknown query parameters are ignored, and an invalid `visit`, +/// `action` or `pipeline` value is dropped rather than failing the route. +/// +/// Parsing is total: an unknown or malformed path resolves to the default +/// Pipelines list instead of throwing, and the serialiser is its inverse for +/// every route the app can produce. class AppRoute { - const AppRoute(this.kind, {this.runId, this.chatSessionId}); + const AppRoute( + this.kind, { + this.runId, + this.chatSessionId, + this.pipelineId, + this.version = 0, + this.stageKey, + this.visit, + this.decide = false, + this.templateKey, + }); static const pipelines = AppRoute(AppRouteKind.pipelines); static const runs = AppRoute(AppRouteKind.runs); @@ -29,74 +58,74 @@ class AppRoute { ? AppRoute(AppRouteKind.chat, chatSessionId: id) : chat; + /// A pipeline detail; [version] 0 is the latest published version. + static AppRoute pipeline(int id, {int version = 0}) => _validId(id) == null + ? pipelines + : AppRoute( + AppRouteKind.pipelines, + pipelineId: id, + version: _latest(version), + ); + + /// The definition pane's stage [stageKey] for pipeline [id]. + static AppRoute pipelineStage(int id, String stageKey, {int version = 0}) => + _validId(id) == null || stageKey.isEmpty + ? pipelines + : AppRoute( + AppRouteKind.pipelines, + pipelineId: id, + version: _latest(version), + stageKey: stageKey, + ); + + /// The Runs list filtered to one pipeline. + static AppRoute runsForPipeline(int pipelineId) => + _validId(pipelineId) == null + ? runs + : AppRoute(AppRouteKind.runs, pipelineId: pipelineId); + + /// One template's detail page, or the gallery for an empty [key]. + static AppRoute template(String key) => key.isEmpty + ? templates + : AppRoute(AppRouteKind.templates, templateKey: key); + final AppRouteKind kind; - /// The run shown by the Runs destination, or null for the list. + /// The run shown by the Runs destination, or null for the list. When + /// [stageKey] is also set, this is the run whose stage pane is open. final int? runId; /// The chat session shown by the Chat destination, or null for the list. final String? chatSessionId; + /// The pipeline shown by the Pipelines destination, or the pipeline the Runs + /// list is filtered to. Null is the unfiltered list. + final int? pipelineId; + + /// The pipeline version for [pipelineId]; 0 is the latest. + final int version; + + /// The stage pane's key, for a pipeline definition or a run visit. + final String? stageKey; + + /// The zero-based visit index for a run's [stageKey], or null when absent. + final int? visit; + + /// Whether a run detail opens its decision prompt (`?action=decide`). + final bool decide; + + /// The template whose detail page is open, or null for the gallery. + final String? templateKey; + /// The path the app writes into history for this route. - String get path => switch (kind) { - AppRouteKind.pipelines => '/pipelines', - AppRouteKind.runs => runId == null ? '/runs' : '/runs/$runId', - AppRouteKind.chat => - chatSessionId == null || !isChatSessionId(chatSessionId!) - ? '/chat' - : '/chat/${Uri.encodeComponent(chatSessionId!)}', - AppRouteKind.search => '/search', - AppRouteKind.settings => '/settings', - AppRouteKind.templates => '/templates', - }; + String get path => _routePath(this); /// Parses a browser pathname (or a full URL) into a route. /// - /// `/runs/abc` and other malformed details are the default route, matching - /// the web parser; `/pipelines/` and other trailing slashes are normalised. - static AppRoute parse(String location) { - var path = location.trim(); - if (path.isEmpty) return pipelines; - if (path.contains('://')) { - final uri = Uri.tryParse(path); - if (uri == null) return pipelines; - path = uri.path; - } - final hash = path.indexOf('#'); - if (hash != -1) path = path.substring(0, hash); - final query = path.indexOf('?'); - if (query != -1) path = path.substring(0, query); - - final segments = []; - for (final raw in path.split('/')) { - if (raw.isEmpty) continue; - try { - segments.add(Uri.decodeComponent(raw)); - } on ArgumentError { - return pipelines; - } - } - if (segments.isEmpty) return pipelines; - - return switch (segments.first) { - 'pipelines' when segments.length == 1 => pipelines, - 'runs' when segments.length == 1 => runs, - 'runs' when segments.length == 2 => _runRoute(segments[1]), - 'chat' when segments.length == 1 => chat, - 'chat' when segments.length == 2 => _chatRoute(segments[1]), - 'search' when segments.length == 1 => search, - 'settings' when segments.length == 1 => settings, - 'templates' when segments.length == 1 => templates, - _ => pipelines, - }; - } - - static AppRoute _runRoute(String value) { - if (!RegExp(r'^[0-9]+$').hasMatch(value)) return pipelines; - final id = int.tryParse(value); - if (id == null || id <= 0) return pipelines; - return AppRoute(AppRouteKind.runs, runId: id); - } + /// `/runs/abc`, `/pipelines/0` and other malformed details are the default + /// route, matching the web parser; `/pipelines/` and other trailing slashes + /// are normalised. + static AppRoute parse(String location) => _parseRoute(location); /// A chat session id is nonempty, bounded and URL-safe, matching the web /// parser. Anything else is malformed rather than a stale session the @@ -106,18 +135,31 @@ class AppRoute { value.length <= 200 && RegExp(r'^[A-Za-z0-9_-]+$').hasMatch(value); - static AppRoute _chatRoute(String value) => - isChatSessionId(value) ? chatSession(value) : pipelines; - @override bool operator ==(Object other) => other is AppRoute && other.kind == kind && other.runId == runId && - other.chatSessionId == chatSessionId; + other.chatSessionId == chatSessionId && + other.pipelineId == pipelineId && + other.version == version && + other.stageKey == stageKey && + other.visit == visit && + other.decide == decide && + other.templateKey == templateKey; @override - int get hashCode => Object.hash(kind, runId, chatSessionId); + int get hashCode => Object.hash( + kind, + runId, + chatSessionId, + pipelineId, + version, + stageKey, + visit, + decide, + templateKey, + ); @override String toString() => path; @@ -127,5 +169,23 @@ class AppRoute { class _RunRouteFactory { const _RunRouteFactory(); - AppRoute call(int id) => AppRoute(AppRouteKind.runs, runId: id); + AppRoute call(int id) => _validId(id) == null + ? AppRoute.runs + : AppRoute(AppRouteKind.runs, runId: id); + + /// One visit's stage pane; [visit] is zero-based and omitted when null. + AppRoute stage(int id, String stageKey, {int? visit}) => + _validId(id) == null || stageKey.isEmpty + ? AppRoute.runs + : AppRoute( + AppRouteKind.runs, + runId: id, + stageKey: stageKey, + visit: _nonNegative(visit), + ); + + /// A run detail with its decision prompt open. + AppRoute decide(int id) => _validId(id) == null + ? AppRoute.runs + : AppRoute(AppRouteKind.runs, runId: id, decide: true); } diff --git a/app/lib/application/app_route_codec.dart b/app/lib/application/app_route_codec.dart new file mode 100644 index 00000000..be2666fe --- /dev/null +++ b/app/lib/application/app_route_codec.dart @@ -0,0 +1,214 @@ +part of 'app_route.dart'; + +/// The largest integer a browser can represent exactly, so ids parsed here +/// survive a round trip through `Number`. +const _maxSafe = 9007199254740991; +final _digits = RegExp(r'^[0-9]+$'); + +String _routePath(AppRoute route) => switch (route.kind) { + AppRouteKind.pipelines => _pipelinePath(route), + AppRouteKind.runs => _runsPath(route), + AppRouteKind.chat => _chatPath(route), + AppRouteKind.search => '/search', + AppRouteKind.settings => '/settings', + AppRouteKind.templates => _templatesPath(route), +}; + +String _pipelinePath(AppRoute route) { + final id = _validId(route.pipelineId); + if (id == null) return '/pipelines'; + final revision = _latest(route.version); + final base = revision == 0 ? '/pipelines/$id' : '/pipelines/$id/$revision'; + final key = route.stageKey; + return key == null || key.isEmpty + ? base + : '$base/stage/${Uri.encodeComponent(key)}'; +} + +String _runsPath(AppRoute route) { + if (route.runId != null) { + final id = _validId(route.runId); + if (id == null) return '/runs'; + final base = '/runs/$id'; + final key = route.stageKey; + if (key != null && key.isNotEmpty) { + final index = _nonNegative(route.visit); + return index == null + ? '$base/stage/${Uri.encodeComponent(key)}' + : '$base/stage/${Uri.encodeComponent(key)}?visit=$index'; + } + return route.decide ? '$base?action=decide' : base; + } + final filter = _validId(route.pipelineId); + return filter == null ? '/runs' : '/runs?pipeline=$filter'; +} + +String _templatesPath(AppRoute route) { + final key = route.templateKey; + return key == null || key.isEmpty + ? '/templates' + : '/templates/${Uri.encodeComponent(key)}'; +} + +String _chatPath(AppRoute route) { + final id = route.chatSessionId; + return id == null || !AppRoute.isChatSessionId(id) + ? '/chat' + : '/chat/${Uri.encodeComponent(id)}'; +} + +/// Parses a pathname plus its optional query. Total: anything unrecognised is +/// the Pipelines list. Unknown query parameters are ignored, and an invalid +/// `visit`, `action` or `pipeline` value is dropped without failing the route. +AppRoute _parseRoute(String location) { + var raw = location.trim(); + if (raw.isEmpty) return AppRoute.pipelines; + + var query = ''; + if (raw.contains('://')) { + final uri = Uri.tryParse(raw); + if (uri == null) return AppRoute.pipelines; + raw = uri.path; + query = uri.query; + } + final hash = raw.indexOf('#'); + if (hash != -1) raw = raw.substring(0, hash); + final mark = raw.indexOf('?'); + if (mark != -1) { + if (query.isEmpty) query = raw.substring(mark + 1); + raw = raw.substring(0, mark); + } + raw = raw.replaceAll(RegExp(r'/+$'), ''); + + final segments = _decodeSegments(raw); + if (segments == null || segments.isEmpty) return AppRoute.pipelines; + final params = _decodeQuery(query); + + return switch (segments.first) { + 'pipelines' => _pipelineRoute(segments), + 'runs' => _runsRoute(segments, params), + 'chat' => _chatRoute(segments), + 'search' when segments.length == 1 => AppRoute.search, + 'settings' => _settingsRoute(segments), + 'templates' => _templatesRoute(segments), + _ => AppRoute.pipelines, + }; +} + +List? _decodeSegments(String path) { + final parts = path.split('/'); + final first = parts.isNotEmpty && parts.first.isEmpty ? 1 : 0; + final values = []; + for (var index = first; index < parts.length; index++) { + if (parts[index].isEmpty) return null; + try { + values.add(Uri.decodeComponent(parts[index])); + } on ArgumentError { + return null; + } + } + return values; +} + +Map _decodeQuery(String query) { + if (query.isEmpty) return const {}; + try { + return Uri.splitQueryString(query); + } on ArgumentError { + return const {}; + } on FormatException { + return const {}; + } +} + +/// `/pipelines/:id[/:version][/stage/:key]`. +AppRoute _pipelineRoute(List segments) { + if (segments.length == 1) return AppRoute.pipelines; + final id = _positiveId(segments[1]); + if (id == null) return AppRoute.pipelines; + if (segments.length == 2) return AppRoute.pipeline(id); + // `stage` comes before a version on purpose: /pipelines/9/stage/7 is the + // pane for stage `7`, not version 7 of pipeline stage `stage`. + if (segments[2] == 'stage') { + return segments.length == 4 + ? AppRoute.pipelineStage(id, segments[3]) + : AppRoute.pipelines; + } + final revision = _number(segments[2]); + if (revision == null) return AppRoute.pipelines; + if (segments.length == 3) return AppRoute.pipeline(id, version: revision); + return segments[3] == 'stage' && segments.length == 5 + ? AppRoute.pipelineStage(id, segments[4], version: revision) + : AppRoute.pipelines; +} + +/// `/runs[?pipeline=]`, `/runs/:id[?action=decide]` and the stage pane. +/// +/// `decide` is the only URL action the app has, so any other `action` value is +/// dropped instead of carried as an opaque string. +AppRoute _runsRoute(List segments, Map params) { + if (segments.length == 1) { + final filter = _positiveId(params['pipeline']); + return filter == null ? AppRoute.runs : AppRoute.runsForPipeline(filter); + } + final id = _positiveId(segments[1]); + if (id == null) return AppRoute.pipelines; + if (segments.length == 2) { + return params['action'] == 'decide' + ? AppRoute.run.decide(id) + : AppRoute.run(id); + } + if (segments[2] == 'stage' && segments.length == 4) { + return AppRoute.run.stage(id, segments[3], visit: _number(params['visit'])); + } + return AppRoute.pipelines; +} + +AppRoute _chatRoute(List segments) { + if (segments.length == 1) return AppRoute.chat; + if (segments.length != 2) return AppRoute.pipelines; + final id = segments[1]; + return AppRoute.isChatSessionId(id) + ? AppRoute.chatSession(id) + : AppRoute.pipelines; +} + +/// `/settings` and the `/settings/templates[/:key]` aliases. +AppRoute _settingsRoute(List segments) { + if (segments.length == 1) return AppRoute.settings; + if (segments[1] != 'templates') return AppRoute.pipelines; + if (segments.length == 2) return AppRoute.templates; + return segments.length == 3 + ? AppRoute.template(segments[2]) + : AppRoute.pipelines; +} + +AppRoute _templatesRoute(List segments) { + if (segments.length == 1) return AppRoute.templates; + return segments.length == 2 + ? AppRoute.template(segments[1]) + : AppRoute.pipelines; +} + +/// A non-negative safe integer, or null. Digits only, so `-1`, `1.5` and an +/// empty value are all dropped exactly where the web parser drops them. +int? _number(String? value) { + if (value == null || !_digits.hasMatch(value)) return null; + final number = int.tryParse(value); + if (number == null || number < 0 || number > _maxSafe) return null; + return number; +} + +/// A positive safe integer, or null. +int? _positiveId(String? value) { + final number = _number(value); + return number == null || number == 0 ? null : number; +} + +int? _validId(int? value) => + value == null || value <= 0 || value > _maxSafe ? null : value; + +int? _nonNegative(int? value) => + value == null || value < 0 || value > _maxSafe ? null : value; + +int _latest(int version) => version > 0 && version <= _maxSafe ? version : 0; diff --git a/app/test/application/app_route_test.dart b/app/test/application/app_route_test.dart index 47171c65..95f88255 100644 --- a/app/test/application/app_route_test.dart +++ b/app/test/application/app_route_test.dart @@ -2,10 +2,28 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/application/app_route.dart'; void main() { - test('parses each destination and a run detail', () { + test('parses each destination, detail and stage pane', () { expect(AppRoute.parse('/pipelines'), AppRoute.pipelines); + expect(AppRoute.parse('/pipelines/5'), AppRoute.pipeline(5)); + expect(AppRoute.parse('/pipelines/5/7'), AppRoute.pipeline(5, version: 7)); + expect( + AppRoute.parse('/pipelines/5/stage/build'), + AppRoute.pipelineStage(5, 'build'), + ); + expect( + AppRoute.parse('/pipelines/5/7/stage/build'), + AppRoute.pipelineStage(5, 'build', version: 7), + ); expect(AppRoute.parse('/runs'), AppRoute.runs); expect(AppRoute.parse('/runs/12'), AppRoute.run(12)); + expect( + AppRoute.parse('/runs/12/stage/build'), + AppRoute.run.stage(12, 'build'), + ); + expect( + AppRoute.parse('/runs/12/stage/build?visit=3'), + AppRoute.run.stage(12, 'build', visit: 3), + ); expect(AppRoute.parse('/chat'), AppRoute.chat); expect( AppRoute.parse('/chat/abc_DEF-123'), @@ -14,6 +32,94 @@ void main() { expect(AppRoute.parse('/search'), AppRoute.search); expect(AppRoute.parse('/settings'), AppRoute.settings); expect(AppRoute.parse('/templates'), AppRoute.templates); + expect(AppRoute.parse('/templates/release'), AppRoute.template('release')); + }); + + test('version before stage: /stage/ is a pane key, not a version', () { + expect( + AppRoute.parse('/pipelines/9/stage/7'), + AppRoute.pipelineStage(9, '7'), + ); + expect( + AppRoute.parse('/pipelines/9/7/stage/7'), + AppRoute.pipelineStage(9, '7', version: 7), + ); + }); + + test('version 0 means latest and is omitted from the path', () { + expect(AppRoute.parse('/pipelines/5/0'), AppRoute.pipeline(5)); + expect(AppRoute.parse('/pipelines/5/0').path, '/pipelines/5'); + expect( + AppRoute.parse('/pipelines/5/0/stage/build'), + AppRoute.pipelineStage(5, 'build'), + ); + expect(AppRoute.pipeline(5, version: 0).path, '/pipelines/5'); + expect(AppRoute.pipeline(5, version: -1).path, '/pipelines/5'); + }); + + test('template aliases resolve to the canonical template route', () { + expect(AppRoute.parse('/settings/templates'), AppRoute.templates); + expect( + AppRoute.parse('/settings/templates/release'), + AppRoute.template('release'), + ); + expect( + AppRoute.parse('/settings/templates/release').path, + '/templates/release', + ); + expect(AppRoute.parse('/settings/templates/a/b'), AppRoute.pipelines); + expect(AppRoute.parse('/settings/other'), AppRoute.pipelines); + expect(AppRoute.parse('/templates/a/b'), AppRoute.pipelines); + }); + + test('runs list pipeline filter and run action are parsed', () { + expect(AppRoute.parse('/runs?pipeline=7'), AppRoute.runsForPipeline(7)); + expect(AppRoute.parse('/runs?pipeline=7').path, '/runs?pipeline=7'); + expect(AppRoute.parse('/runs?pipeline=0'), AppRoute.runs); + expect(AppRoute.parse('/runs?pipeline=abc'), AppRoute.runs); + expect(AppRoute.parse('/runs/5?action=decide'), AppRoute.run.decide(5)); + expect(AppRoute.run.decide(5).path, '/runs/5?action=decide'); + expect(AppRoute.parse('/runs/5?action='), AppRoute.run(5)); + expect(AppRoute.parse('/runs/5?action=retry'), AppRoute.run(5)); + expect(AppRoute.parse('/runs/5?action=retry').path, '/runs/5'); + }); + + test('unknown query parameters are ignored and invalid values dropped', () { + expect( + AppRoute.parse('/runs/5/stage/build?visit=-1'), + AppRoute.run.stage(5, 'build'), + ); + expect( + AppRoute.parse('/runs/5/stage/build?visit=1.5'), + AppRoute.run.stage(5, 'build'), + ); + expect( + AppRoute.parse('/runs/5/stage/build?visit=abc'), + AppRoute.run.stage(5, 'build'), + ); + expect( + AppRoute.parse('/runs/5/stage/build?visit=0&x=1'), + AppRoute.run.stage(5, 'build', visit: 0), + ); + expect( + AppRoute.parse('/runs/5/stage/build?visit=99999999999999999999'), + AppRoute.run.stage(5, 'build'), + ); + expect( + AppRoute.parse('/runs/5/stage/build?action=decide'), + AppRoute.run.stage(5, 'build'), + ); + expect(AppRoute.parse('/runs/5?pipeline=7'), AppRoute.run(5)); + expect(AppRoute.parse('/runs/5?x=1'), AppRoute.run(5)); + expect(AppRoute.parse('/runs/5?x=%E0%A4%A'), AppRoute.run(5)); + expect( + AppRoute.parse('/pipelines/5/stage/build?visit=2'), + AppRoute.pipelineStage(5, 'build'), + ); + expect( + AppRoute.parse('/templates/release?x=1'), + AppRoute.template('release'), + ); }); test('normalises slashes and accepts a full URL, query and fragment', () { @@ -22,7 +128,11 @@ void main() { expect(AppRoute.parse('/templates/'), AppRoute.templates); expect( AppRoute.parse('http://127.0.0.1:8096/runs/7?action=decide#top'), - AppRoute.run(7), + AppRoute.run.decide(7), + ); + expect( + AppRoute.parse('https://example.test/runs/7/stage/build?visit=2#top'), + AppRoute.run.stage(7, 'build', visit: 2), ); expect(AppRoute.parse('/runs/7/'), AppRoute.run(7)); expect( @@ -43,9 +153,20 @@ void main() { '/runs/0', '/runs/-1', '/runs/1/extra', - '/pipelines/2', + '/runs/5/stage', + '/runs/5/stage/a/b', + '/runs/5/stage/', + '/pipelines/0', + '/pipelines/abc', + '/pipelines/5/abc', + '/pipelines/5/-1', + '/pipelines/5/stage', + '/pipelines/5/stage/a/b', + '/pipelines/5/1/2', '/search/1', - '/templates/release', + '/runs/9007199254740992', + '/pipelines/9007199254740992', + '/templates/a/b', '/chat/a/b', '/chat/%2F', '/chat/${'x' * 201}', @@ -59,19 +180,70 @@ void main() { test('serialises every route back to a parsable path', () { for (final route in [ AppRoute.pipelines, + AppRoute.pipeline(5), + AppRoute.pipeline(5, version: 2), + AppRoute.pipelineStage(5, 'build'), + AppRoute.pipelineStage(5, 'build', version: 2), + AppRoute.pipelineStage(5, 'a/b'), AppRoute.runs, + AppRoute.runsForPipeline(7), AppRoute.run(3), + AppRoute.run.decide(3), + AppRoute.run.stage(3, 'build'), + AppRoute.run.stage(3, 'build', visit: 0), + AppRoute.run.stage(3, 'build', visit: 4), AppRoute.chat, AppRoute.chatSession('probe_open-1'), AppRoute.search, AppRoute.settings, AppRoute.templates, + AppRoute.template('release'), + AppRoute.template('release notes'), + AppRoute.template('café'), + AppRoute.pipelineStage(5, 'build ✓'), ]) { - expect(AppRoute.parse(route.path), route); + expect(AppRoute.parse(route.path), route, reason: route.path); } expect(AppRoute.run(3).path, '/runs/3'); expect(AppRoute.chatSession('probe_open-1').path, '/chat/probe_open-1'); expect(AppRoute.chatSession('bad id').path, '/chat'); expect(AppRoute.templates.path, '/templates'); }); + + test('canonical paths for the extended vocabulary', () { + expect(AppRoute.pipeline(5).path, '/pipelines/5'); + expect(AppRoute.pipeline(5, version: 2).path, '/pipelines/5/2'); + expect(AppRoute.pipelineStage(5, 'build').path, '/pipelines/5/stage/build'); + expect( + AppRoute.pipelineStage(5, 'build', version: 2).path, + '/pipelines/5/2/stage/build', + ); + expect( + AppRoute.pipelineStage(5, 'release notes').path, + '/pipelines/5/stage/release%20notes', + ); + expect(AppRoute.runsForPipeline(7).path, '/runs?pipeline=7'); + expect(AppRoute.run.decide(3).path, '/runs/3?action=decide'); + expect( + AppRoute.run.stage(3, 'build', visit: 2).path, + '/runs/3/stage/build?visit=2', + ); + expect(AppRoute.run.stage(3, 'build').path, '/runs/3/stage/build'); + expect(AppRoute.template('release').path, '/templates/release'); + expect(AppRoute.template('').path, '/templates'); + }); + + test('invalid ids never serialise outside the vocabulary', () { + expect(AppRoute.pipeline(0), AppRoute.pipelines); + expect(AppRoute.pipeline(-1), AppRoute.pipelines); + expect(AppRoute.pipelineStage(0, 'build'), AppRoute.pipelines); + expect(AppRoute.pipelineStage(5, ''), AppRoute.pipelines); + expect(AppRoute.runsForPipeline(0), AppRoute.runs); + expect(AppRoute.run(0), AppRoute.runs); + expect(AppRoute.run.stage(0, 'build'), AppRoute.runs); + expect(AppRoute.run.stage(3, ''), AppRoute.runs); + expect(AppRoute.run.decide(0), AppRoute.runs); + expect(AppRoute(AppRouteKind.pipelines, pipelineId: 0).path, '/pipelines'); + expect(AppRoute(AppRouteKind.runs, runId: 0).path, '/runs'); + }); }