import 'dart:async'; import 'dart:io'; import 'dart:typed_data'; import 'dart:ui' as ui; import 'package:flutter/material.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/core/session/server_session.dart'; import 'package:pipelines_app/features/artifacts/ui/artifact_viewer_fetch.dart'; import 'package:pipelines_app/features/chat/data/directory_listing.dart'; import 'package:pipelines_app/features/chat/files/files_thumbnail.dart'; import 'package:pipelines_app/features/chat/files/files_thumbnail_image.dart'; import 'package:shared_preferences/shared_preferences.dart'; Future imageFrom(ImageProvider provider) async { final result = Completer(); final stream = provider.resolve(ImageConfiguration.empty); final listener = ImageStreamListener( (info, _) => result.complete(info.image.clone()), onError: (Object error, StackTrace? stack) => result.completeError(error), ); stream.addListener(listener); try { return await result.future; } finally { stream.removeListener(listener); await provider.evict(); } } void main() { TestWidgetsFlutterBinding.ensureInitialized(); setUp(() => SharedPreferences.setMockInitialValues({})); tearDown(() { ServerSession.clearSelection(); PaintingBinding.instance.imageCache.clear(); PaintingBinding.instance.imageCache.clearLiveImages(); }); test('cache identity follows credentials without exposing them', () { final uri = Uri.parse('https://machine.test/files?path=image.png'); var headers = {'Cookie': 'private-cookie-a'}; Map reader(Uri _) => headers; final first = FileThumbnailImage(uri, headers: reader); expect(FileThumbnailImage(uri, headers: reader), first); expect(first.toString(), isNot(contains('private-cookie-a'))); headers = {'Cookie': 'private-cookie-b'}; final changed = FileThumbnailImage(uri, headers: reader); expect(changed, isNot(first)); expect(changed.hashCode, isNot(first.hashCode)); }); test( 'native thumbnails authenticate their own origin and refuse redirects', () async { final previous = HttpOverrides.current; HttpOverrides.global = null; final trusted = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); final other = await HttpServer.bind(InternetAddress.loopbackIPv4, 0); final uri = Uri.parse( 'http://127.0.0.1:${trusted.port}/files?path=image.png', ); final observed = []; var forwarded = 0; trusted.listen((request) async { observed.add(request.headers.value('cookie')); request.response.statusCode = HttpStatus.found; request.response.headers.set( 'Location', 'http://127.0.0.1:${other.port}/stolen', ); await request.response.close(); }); other.listen((request) async { forwarded++; await request.response.close(); }); try { SharedPreferences.setMockInitialValues({ 'pipelines.session.v2.peer.cookie': 'pipelines_session=peer-only', }); await ServerSession.activateServer(id: 'peer', endpoints: [uri]); await expectLater( imageFrom(FileThumbnailImage(uri)), throwsA(isA()), ); expect(observed, ['pipelines_session=peer-only']); expect(forwarded, 0); } finally { await trusted.close(force: true); await other.close(force: true); HttpOverrides.global = previous; } }, ); test('a changed login cannot populate the old thumbnail cache key', () async { var headers = {'Cookie': 'first'}; final response = Completer(); final requested = Completer(); final provider = FileThumbnailImage( Uri.parse('https://machine.test/files'), headers: (_) => headers, fetch: (_) { requested.complete(); return response.future; }, ); final rejected = expectLater(imageFrom(provider), throwsStateError); await requested.future; headers = {'Cookie': 'second'}; response.complete(ArtifactFetchResult(status: 200, bytes: Uint8List(0))); await rejected; final key = await provider.obtainKey(ImageConfiguration.empty); expect(PaintingBinding.instance.imageCache.containsKey(key), false); }); test( 'large images decode at the existing cap and evict their cache entry', () async { final recorder = ui.PictureRecorder(); Canvas(recorder).drawRect( const Rect.fromLTWH(0, 0, 800, 800), Paint()..color = Colors.blue, ); final picture = recorder.endRecording(); final original = await picture.toImage(800, 800); final bytes = (await original.toByteData( format: ui.ImageByteFormat.png, ))!.buffer.asUint8List(); original.dispose(); picture.dispose(); final provider = ResizeImage( FileThumbnailImage( Uri.parse('https://machine.test/files'), headers: (_) => const {}, fetch: (_) async => ArtifactFetchResult(status: 200, bytes: bytes), ), width: filesThumbnailDecodeSize(10), height: filesThumbnailDecodeSize(10), ); final decoded = await imageFrom(provider); expect((decoded.width, decoded.height), (224, 224)); decoded.dispose(); final key = await provider.obtainKey(ImageConfiguration.empty); expect(PaintingBinding.instance.imageCache.containsKey(key), false); }, ); testWidgets('same file gets a fresh provider after its login changes', ( tester, ) async { await ServerSession.activateServer( id: 'peer', endpoints: [Uri.parse('ws://peer.test/connect')], ); ServerSession.cookie = 'pipelines_session=first'; const entry = DirectoryEntry( name: 'image.png', path: '/image.png', isDir: false, isGitRepo: false, hidden: false, ); Future pump() async { await tester.pumpWidget( MaterialApp( home: FileThumbnail(entry: entry, endpoint: 'ws://peer.test/connect'), ), ); await tester.pumpAndSettle(); } await pump(); final first = tester.widget(find.byType(Image)).image; ServerSession.cookie = 'pipelines_session=second'; await pump(); final second = tester.widget(find.byType(Image)).image; expect(second, isNot(first)); expect(tester.takeException(), isNull); }); }