342 lines
9.8 KiB
Dart
342 lines
9.8 KiB
Dart
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:pipelines_app/features/artifacts/domain/artifact_groups.dart';
|
|
import 'package:pipelines_app/features/artifacts/domain/artifact_selection.dart';
|
|
|
|
import 'artifact_fixtures.dart';
|
|
|
|
void main() {
|
|
group('grouping', () {
|
|
test('groups interleaved steps by stage then recorded visit', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'planner',
|
|
sequence: 1,
|
|
visit: 1,
|
|
artifacts: <Map<String, dynamic>>[artifact('a.png')],
|
|
),
|
|
step(
|
|
stage: 'build',
|
|
sequence: 2,
|
|
visit: 1,
|
|
artifacts: <Map<String, dynamic>>[artifact('b.png')],
|
|
),
|
|
step(
|
|
stage: 'planner',
|
|
sequence: 3,
|
|
visit: 2,
|
|
artifacts: <Map<String, dynamic>>[artifact('c.png')],
|
|
),
|
|
];
|
|
|
|
final groups = artifactGroups(steps);
|
|
expect(
|
|
groups.map((group) => '${group.stageKey}/${group.visit}'),
|
|
<String>['planner/1', 'planner/2', 'build/1'],
|
|
);
|
|
expect(groups.first.artifacts.map((record) => record.name), <String>[
|
|
'a.png',
|
|
]);
|
|
});
|
|
|
|
test('repeated stage visits stay separate and ordered by sequence', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'review',
|
|
sequence: 7,
|
|
visit: 2,
|
|
artifacts: <Map<String, dynamic>>[artifact('second.md')],
|
|
),
|
|
step(
|
|
stage: 'review',
|
|
sequence: 3,
|
|
visit: 1,
|
|
artifacts: <Map<String, dynamic>>[artifact('first.md')],
|
|
),
|
|
];
|
|
|
|
final groups = artifactGroups(steps);
|
|
expect(groups.map((group) => group.visit), <int>[1, 2]);
|
|
expect(groups.map((group) => group.artifacts.single.name), <String>[
|
|
'first.md',
|
|
'second.md',
|
|
]);
|
|
});
|
|
|
|
test(
|
|
'a display visit is control.visit when positive, else position + 1',
|
|
() {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 's',
|
|
sequence: 1,
|
|
visit: 0,
|
|
artifacts: <Map<String, dynamic>>[artifact('a')],
|
|
),
|
|
step(
|
|
stage: 's',
|
|
sequence: 2,
|
|
visit: 0,
|
|
artifacts: <Map<String, dynamic>>[artifact('b')],
|
|
),
|
|
];
|
|
expect(artifactGroups(steps).map((group) => group.visit), <int>[1, 2]);
|
|
},
|
|
);
|
|
|
|
test('equal sequences keep recorded order', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 's',
|
|
sequence: 1,
|
|
visit: 1,
|
|
artifacts: <Map<String, dynamic>>[artifact('first')],
|
|
),
|
|
step(
|
|
stage: 's',
|
|
sequence: 1,
|
|
visit: 2,
|
|
artifacts: <Map<String, dynamic>>[artifact('second')],
|
|
),
|
|
];
|
|
expect(
|
|
artifactGroups(steps).map((group) => group.artifacts.single.name),
|
|
<String>['first', 'second'],
|
|
);
|
|
});
|
|
|
|
test('an absent stage visit is not fabricated', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'a',
|
|
sequence: 1,
|
|
artifacts: <Map<String, dynamic>>[artifact('a.png')],
|
|
),
|
|
];
|
|
final groups = artifactGroups(steps);
|
|
expect(groups.single.stageKey, 'a');
|
|
expect(groups.any((group) => group.stageKey == 'b'), isFalse);
|
|
});
|
|
});
|
|
|
|
group('identity', () {
|
|
test('the same file name in different visits remains two groups', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'implementer',
|
|
sequence: 1,
|
|
visit: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('report.md', url: '/artifacts/1/1/report.md'),
|
|
],
|
|
),
|
|
step(
|
|
stage: 'implementer',
|
|
sequence: 2,
|
|
visit: 2,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('report.md', url: '/artifacts/1/2/report.md'),
|
|
],
|
|
),
|
|
];
|
|
final groups = artifactGroups(steps);
|
|
expect(groups.length, 2);
|
|
expect(groups.map((group) => group.artifacts.single.url), <String>[
|
|
'/artifacts/1/1/report.md',
|
|
'/artifacts/1/2/report.md',
|
|
]);
|
|
});
|
|
|
|
test('duplicate names in one visit are kept with their recorded urls', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 's',
|
|
sequence: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('shot.png', url: '/artifacts/1/1/shot-a.png'),
|
|
artifact('shot.png', url: '/artifacts/1/1/shot-b.png'),
|
|
],
|
|
),
|
|
];
|
|
final artifacts = artifactGroups(steps).single.artifacts;
|
|
expect(artifacts.length, 2);
|
|
expect(artifacts.map((record) => record.url), <String>[
|
|
'/artifacts/1/1/shot-a.png',
|
|
'/artifacts/1/1/shot-b.png',
|
|
]);
|
|
});
|
|
|
|
test('the retired session.md is hidden but session.html is retained', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 's',
|
|
sequence: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('session.md'),
|
|
artifact('session.html'),
|
|
artifact('report.md'),
|
|
],
|
|
),
|
|
];
|
|
// session.html is retained as system evidence, but neither it nor the
|
|
// retired session.md is stage output, so the gallery shows only the report.
|
|
expect(
|
|
artifactGroups(steps).single.artifacts.map((record) => record.name),
|
|
<String>['report.md'],
|
|
);
|
|
expect(
|
|
systemArtifacts(steps.single).map((record) => record.name),
|
|
<String>['session.html'],
|
|
);
|
|
});
|
|
});
|
|
|
|
group('shared public files', () {
|
|
test('a public file is attributed to the visit that first recorded it', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'a',
|
|
sequence: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('input.md'),
|
|
artifact('public/a.txt'),
|
|
],
|
|
),
|
|
step(
|
|
stage: 'b',
|
|
sequence: 2,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('output.md'),
|
|
artifact('public/a.txt'),
|
|
artifact('public/b.txt'),
|
|
],
|
|
),
|
|
];
|
|
final groups = artifactGroups(steps);
|
|
expect(
|
|
groups.map(
|
|
(group) => group.artifacts.map((record) => record.name).toList(),
|
|
),
|
|
<List<String>>[
|
|
<String>['public/a.txt'],
|
|
<String>['public/b.txt'],
|
|
],
|
|
);
|
|
expect(
|
|
visitArtifacts(steps[1], steps).map((record) => record.name),
|
|
<String>['public/b.txt'],
|
|
);
|
|
});
|
|
|
|
test(
|
|
'visitArtifacts keeps a repeated non-public name in a later visit',
|
|
() {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'a',
|
|
sequence: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('report.md', url: '/artifacts/1/1/report.md'),
|
|
],
|
|
),
|
|
step(
|
|
stage: 'a',
|
|
sequence: 2,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('report.md', url: '/artifacts/1/2/report.md'),
|
|
],
|
|
),
|
|
];
|
|
expect(
|
|
visitArtifacts(steps[1], steps).map((record) => record.url),
|
|
<String>['/artifacts/1/2/report.md'],
|
|
);
|
|
},
|
|
);
|
|
|
|
test('a public file repeated inside one visit is recorded once', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'a',
|
|
sequence: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('public/a.txt'),
|
|
artifact('public/a.txt'),
|
|
],
|
|
),
|
|
];
|
|
expect(artifactGroups(steps).single.artifacts.length, 1);
|
|
});
|
|
|
|
test('visitArtifactGroup matches the pane group of a later visit', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'a',
|
|
sequence: 1,
|
|
visit: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('public/shared.csv'),
|
|
artifact('a.csv'),
|
|
],
|
|
),
|
|
step(
|
|
stage: 'a',
|
|
sequence: 2,
|
|
visit: 2,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('public/shared.csv'),
|
|
artifact('b.csv'),
|
|
],
|
|
),
|
|
];
|
|
final group = visitArtifactGroup(steps, 1)!;
|
|
expect(group.stageKey, 'a');
|
|
expect(group.visit, 2);
|
|
expect(group.artifacts.map((record) => record.name), <String>['b.csv']);
|
|
expect(
|
|
visitArtifacts(steps[1], steps).map((record) => record.name),
|
|
<String>['b.csv'],
|
|
);
|
|
expect(visitArtifactGroup(steps, 2), isNull);
|
|
expect(visitArtifactGroup(steps, -1), isNull);
|
|
});
|
|
});
|
|
|
|
group('unavailable and empty captures', () {
|
|
test('unavailable, null and empty visits yield no group', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(stage: 'a', sequence: 1, includeArtifacts: false),
|
|
step(stage: 'a', sequence: 2, artifacts: null),
|
|
step(stage: 'a', sequence: 3, artifacts: const []),
|
|
step(
|
|
stage: 'b',
|
|
sequence: 4,
|
|
artifacts: <Map<String, dynamic>>[artifact('only.png')],
|
|
),
|
|
];
|
|
final groups = artifactGroups(steps);
|
|
expect(groups.length, 1);
|
|
expect(groups.single.stageKey, 'b');
|
|
expect(groups.single.visit, 1);
|
|
});
|
|
|
|
test('a visit with only utility or retired files yields no group', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'a',
|
|
sequence: 1,
|
|
artifacts: <Map<String, dynamic>>[
|
|
artifact('input.md'),
|
|
artifact('session.md'),
|
|
artifact('session.html'),
|
|
],
|
|
),
|
|
];
|
|
expect(artifactGroups(steps), isEmpty);
|
|
});
|
|
|
|
test('an empty run yields no groups', () {
|
|
expect(artifactGroups(const []), isEmpty);
|
|
});
|
|
});
|
|
}
|