import "dart:convert"; import "dart:io"; import "package:flutter_test/flutter_test.dart"; import "package:garage_updates/core.dart"; import "support/fake_server.dart"; void main() { late FakeServer server; late Directory staging; final data = noise(200 * 1024); Downloader make({int retries = 0}) => Downloader( httpClient: HttpClient(), retries: retries, retryPause: const Duration(milliseconds: 10), quietTimeout: const Duration(seconds: 5), ); setUp(() async { server = await FakeServer.start(data); staging = Directory("${Directory.systemTemp.createTempSync("gu_dl_").path}/staging"); }); tearDown(() async { await server.close(); if (staging.parent.existsSync()) staging.parent.deleteSync(recursive: true); }); test("downloads, verifies and renames", () async { final release = server.release(); final seen = []; int? total; final file = await make().fetch( release: release, staging: staging, onProgress: (got, t) { seen.add(got); total = t; }, ); expect(file.path, Downloader.finishedFile(staging, release).path); expect(file.path.endsWith("update-13.zip"), isTrue); expect(file.readAsBytesSync(), data); expect(seen.last, data.length); expect(total, data.length); // nothing left lying about expect(Downloader.partFile(staging).existsSync(), isFalse); expect(Downloader.metaFile(staging).existsSync(), isFalse); }); test("a cut connection keeps the part, and the next go resumes with Range", () async { final release = server.release(); server.cutsLeft = 1; server.cutAfter = 50 * 1024; await expectLater( make().fetch(release: release, staging: staging), throwsA(isA().having((e) => e.code, "code", "download")), ); final part = Downloader.partFile(staging); expect(part.existsSync(), isTrue); final had = part.lengthSync(); expect(had, greaterThan(0)); expect(had, lessThan(data.length)); expect(Downloader.metaFile(staging).existsSync(), isTrue); int? firstProgress; final file = await make().fetch( release: release, staging: staging, onProgress: (got, _) => firstProgress ??= got, ); expect(server.log, ["GET /blob", "GET /blob bytes=$had-"]); expect(file.readAsBytesSync(), data); // progress carried on from where it was, not from nought expect(firstProgress, had); }); test("retries by itself, resuming each time", () async { final release = server.release(); server.cutsLeft = 2; server.cutAfter = 30 * 1024; final file = await make(retries: 3).fetch(release: release, staging: staging); expect(file.readAsBytesSync(), data); expect(server.log.length, 3); expect(server.log[0], "GET /blob"); expect(server.log[1], startsWith("GET /blob bytes=")); expect(server.log[2], startsWith("GET /blob bytes=")); }); test("a 200 that ignored the range starts the file again", () async { final release = server.release(); server.cutsLeft = 1; server.cutAfter = 50 * 1024; await expectLater(make().fetch(release: release, staging: staging), throwsA(isA())); server.ignoreRange = true; final file = await make().fetch(release: release, staging: staging); expect(server.log.last, startsWith("GET /blob bytes=")); // not the old half with the whole file stuck on the end expect(file.lengthSync(), data.length); expect(file.readAsBytesSync(), data); }); test("a hosted download follows the 302, and asks the original url again on resume", () async { final release = server.release(path: "/hosted"); server.cutsLeft = 1; server.cutAfter = 40 * 1024; await expectLater(make().fetch(release: release, staging: staging), throwsA(isA())); final had = Downloader.partFile(staging).lengthSync(); // the first presigned url is dead by now. going straight back to it would 403 final file = await make().fetch(release: release, staging: staging); expect(server.log, [ "GET /hosted", "GET /blob", "GET /hosted bytes=$had-", "GET /blob bytes=$had-", ]); expect(file.readAsBytesSync(), data); }); test("a checksum mismatch deletes the download and fails", () async { final release = server.release(sha256: "0" * 64); await expectLater( make(retries: 3).fetch(release: release, staging: staging), throwsA(isA().having((e) => e.code, "code", "checksum_mismatch")), ); expect(Downloader.partFile(staging).existsSync(), isFalse); expect(Downloader.metaFile(staging).existsSync(), isFalse); expect(Downloader.finishedFile(staging, release).existsSync(), isFalse); // and it wasnt retried, the same bytes would come back expect(server.log.length, 1); }); test("a stale part for another build is thrown away", () async { staging.createSync(recursive: true); Downloader.partFile(staging).writeAsBytesSync(noise(10 * 1024, seed: 99)); Downloader.metaFile(staging).writeAsStringSync(jsonEncode({"build": 12, "sha256": "f" * 64})); final file = await make().fetch(release: server.release(), staging: staging); // no Range, it didnt try to carry on from someone elses bytes expect(server.log, ["GET /blob"]); expect(file.readAsBytesSync(), data); }); test("a part for the same build but another sha is stale too", () async { staging.createSync(recursive: true); Downloader.partFile(staging).writeAsBytesSync(noise(10 * 1024, seed: 99)); Downloader.metaFile(staging).writeAsStringSync(jsonEncode({"build": 13, "sha256": "f" * 64})); await make().fetch(release: server.release(), staging: staging); expect(server.log, ["GET /blob"]); }); test("a part with no note beside it is stale", () async { staging.createSync(recursive: true); Downloader.partFile(staging).writeAsBytesSync(noise(10 * 1024, seed: 99)); final file = await make().fetch(release: server.release(), staging: staging); expect(server.log, ["GET /blob"]); expect(file.readAsBytesSync(), data); }); test("a part that is allready whole only gets verified", () async { final release = server.release(); staging.createSync(recursive: true); Downloader.partFile(staging).writeAsBytesSync(data); Downloader.metaFile(staging) .writeAsStringSync(jsonEncode({"build": release.build, "sha256": release.asset.sha256})); final file = await make().fetch(release: release, staging: staging); expect(server.log, isEmpty); expect(file.readAsBytesSync(), data); }); test("a finished download is reused, and other builds' are swept", () async { final release = server.release(); await make().fetch(release: release, staging: staging); File("${staging.path}/update-9.zip").writeAsStringSync("old"); server.log.clear(); await make().fetch(release: release, staging: staging); expect(server.log, isEmpty); // asking for a newer one clears the old finished files out server.data = server.data.sublist(0, 1000); final next = server.release(build: 14); await make().fetch(release: next, staging: staging); expect(File("${staging.path}/update-9.zip").existsSync(), isFalse); expect(Downloader.finishedFile(staging, release).existsSync(), isFalse); expect(Downloader.finishedFile(staging, next).existsSync(), isTrue); }); test("a 404 fails without retrying", () async { await expectLater( make(retries: 3).fetch(release: server.release(path: "/gone"), staging: staging), throwsA(isA().having((e) => e.code, "code", "http_404")), ); expect(server.log.length, 1); }); test("a release with no checksum is refused", () async { await expectLater( make().fetch(release: server.release(sha256: ""), staging: staging), throwsA(isA().having((e) => e.code, "code", "no_checksum")), ); expect(server.log, isEmpty); }); test("a line that goes quiet times out", () async { // accepts the connection and then says nothing at all final silent = await ServerSocket.bind(InternetAddress.loopbackIPv4, 0); final held = []; silent.listen(held.add); final release = UpdateRelease( label: "v13", build: 13, asset: UpdateAsset( url: "http://127.0.0.1:${silent.port}/blob", filename: "app.zip", format: "zip", size: data.length, sha256: server.sha, ), ); final d = Downloader( httpClient: HttpClient(), retries: 0, quietTimeout: const Duration(milliseconds: 300), ); await expectLater( d.fetch(release: release, staging: staging), throwsA(isA().having((e) => e.code, "code", "download")), ); d.close(); for (final s in held) { s.destroy(); } await silent.close(); }); }