183 lines
6.4 KiB
Dart
183 lines
6.4 KiB
Dart
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<ui.Image> imageFrom(ImageProvider provider) async {
|
|
final result = Completer<ui.Image>();
|
|
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<String, String> 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 = <String?>[];
|
|
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<NetworkImageLoadException>()),
|
|
);
|
|
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<ArtifactFetchResult>();
|
|
final requested = Completer<void>();
|
|
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<void> pump() async {
|
|
await tester.pumpWidget(
|
|
MaterialApp(
|
|
home: FileThumbnail(entry: entry, endpoint: 'ws://peer.test/connect'),
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
}
|
|
|
|
await pump();
|
|
final first = tester.widget<Image>(find.byType(Image)).image;
|
|
ServerSession.cookie = 'pipelines_session=second';
|
|
await pump();
|
|
final second = tester.widget<Image>(find.byType(Image)).image;
|
|
expect(second, isNot(first));
|
|
expect(tester.takeException(), isNull);
|
|
});
|
|
}
|