import 'dart:async'; import 'dart:typed_data'; import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/features/artifacts/actions/artifact_file.dart'; import 'package:pipelines_app/features/artifacts/actions/artifact_file_bridge.dart'; import 'package:pipelines_app/features/artifacts/actions/artifact_file_controller.dart'; import 'package:pipelines_app/features/artifacts/actions/artifact_transfer.dart'; import 'package:pipelines_app/features/artifacts/domain/artifact_record.dart'; import 'package:pipelines_app/features/artifacts/domain/artifact_url.dart'; import 'package:pipelines_app/features/artifacts/ui/artifact_viewer_fetch.dart'; const _url = 'http://127.0.0.1:8081/artifacts/1/1/report.csv'; final Uint8List _bytes = Uint8List.fromList([10, 20, 30, 40]); final ArtifactRecord _record = ArtifactRecord.fromJson({ 'name': 'public/reports/report.csv', 'url': '/artifacts/1/1/report.csv', 'content_type': 'text/csv; charset=utf-8', 'size_bytes': 4, }); ArtifactFileActionsController _controller({ ArtifactFetch? fetch, ArtifactFileBridge bridge = const ArtifactFileBridge(), }) => ArtifactFileActionsController( artifact: _record, resolved: resolveArtifactUrl('ws://127.0.0.1:8081/connect', _record.url)!, fetch: fetch ?? (_) async => ArtifactFetchResult(status: 200, bytes: _bytes), bridge: bridge, ); ArtifactFileBridge _bridge({ List? saved, List? shared, ArtifactTransferResult shareResult = const ArtifactTransferResult( ArtifactTransferState.shared, 'File shared.', ), bool downloadSupported = true, bool shareSupported = true, }) => ArtifactFileBridge( downloadSupported: downloadSupported, shareSupported: shareSupported, downloadUnsupportedMessage: 'No download here.', shareUnsupportedMessage: 'No share here.', download: (file) async { saved?.add(file); return ArtifactTransferResult( ArtifactTransferState.saved, 'Downloaded ${file.name}.', ); }, share: (file) async { shared?.add(file); return shareResult; }, ); void main() { test('download carries the exact named, typed bytes', () async { final saved = []; final controller = _controller(bridge: _bridge(saved: saved)); await controller.download(); expect(saved, hasLength(1)); expect(saved.single.name, 'report.csv'); expect(saved.single.mimeType, 'text/csv'); expect(saved.single.bytes, _bytes); expect(controller.status, 'Downloaded report.csv.'); expect(controller.busy, isFalse); }); test('share uses a file, not a link, and reports when shared', () async { final shared = []; final fetched = []; final controller = _controller( bridge: _bridge(shared: shared), fetch: (uri) async { fetched.add(uri); return ArtifactFetchResult(status: 200, bytes: _bytes); }, ); await controller.share(); expect(fetched, [Uri.parse(_url)]); expect(shared, hasLength(1)); expect(shared.single.name, 'report.csv'); expect(shared.single.mimeType, 'text/csv'); expect(shared.single.bytes, _bytes); expect(controller.canShare, isTrue); expect(controller.status, 'File shared.'); }); test('unsupported sharing leaves download working', () async { final saved = []; final shared = []; var fetches = 0; final controller = _controller( fetch: (_) async { fetches += 1; return ArtifactFetchResult(status: 200, bytes: _bytes); }, bridge: _bridge(saved: saved, shared: shared, shareSupported: false), ); await controller.share(); expect(shared, isEmpty); expect(fetches, 0); expect(controller.status, 'No share here.'); expect(controller.canDownload, isTrue); await controller.download(); expect(saved, hasLength(1)); expect(controller.status, 'Downloaded report.csv.'); }); test( 'an HTTP or network fetch failure is reported, never transferred', () async { final saved = []; final bridge = _bridge(saved: saved); final notFound = _controller( fetch: (_) async => ArtifactFetchResult(status: 404, bytes: Uint8List(0)), bridge: bridge, ); await notFound.download(); expect(notFound.status, 'Could not fetch the artifact (HTTP 404).'); expect(saved, isEmpty); expect(notFound.busy, isFalse); final offline = _controller( fetch: (_) async => throw const ArtifactFetchException('network down'), bridge: bridge, ); await offline.download(); expect(offline.status, contains('network down')); expect(saved, isEmpty); }, ); test( 'cancel during a slow fetch starts no transfer and ignores the result', () async { final pending = Completer(); final saved = []; final controller = _controller( fetch: (_) => pending.future, bridge: _bridge(saved: saved), ); final action = controller.download(); await Future.delayed(Duration.zero); expect(controller.busy, isTrue); expect(controller.canCancel, isTrue); expect(controller.status, 'Preparing file…'); controller.cancel(); expect(controller.busy, isFalse); expect(controller.status, 'Download canceled.'); pending.complete(ArtifactFetchResult(status: 200, bytes: _bytes)); await action; expect(saved, isEmpty); expect(controller.status, 'Download canceled.'); }, ); test('one tap starts one transfer even when called twice', () async { var fetches = 0; final pending = Completer(); final saved = []; final controller = _controller( fetch: (_) { fetches += 1; return pending.future; }, bridge: _bridge(saved: saved), ); final first = controller.download(); final second = controller.download(); await Future.delayed(Duration.zero); expect(fetches, 1); pending.complete(ArtifactFetchResult(status: 200, bytes: _bytes)); await first; await second; expect(saved, hasLength(1)); }); test('a ready share reuses prepared bytes on the fresh tap', () async { var fetches = 0; var shares = 0; final controller = _controller( fetch: (_) async { fetches += 1; return ArtifactFetchResult(status: 200, bytes: _bytes); }, bridge: ArtifactFileBridge( shareSupported: true, share: (file) async { shares += 1; return shares == 1 ? const ArtifactTransferResult( ArtifactTransferState.ready, 'File ready. Tap Share again to choose where to send it.', ) : const ArtifactTransferResult( ArtifactTransferState.shared, 'File shared.', ); }, ), ); await controller.share(); expect(controller.status, contains('Tap Share again')); await controller.share(); expect(fetches, 1); expect(shares, 2); expect(controller.status, 'File shared.'); }); }