Files
ImBenjiandClaude Opus 5.5 d3b232f0ee feat(garage_updates): an auto updater for garage apps
Asks Garage for the newest release of a project, downloads it with resume,
checks the sha256, installs it beside the old one and restarts into it.
Splash on garage_ui, a native stub and a first time installer for windows,
bundle swap on mac, the system installer on android. No-op on web.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KHotisA4hV2xmuZsHTksFX
2026-10-12 06:37:02 +01:00

261 lines
8.8 KiB
Dart

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>[];
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<UpdateError>().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<UpdateError>()));
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<UpdateError>()));
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<UpdateError>().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<UpdateError>().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<UpdateError>().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 = <Socket>[];
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<UpdateError>().having((e) => e.code, "code", "download")),
);
d.close();
for (final s in held) {
s.destroy();
}
await silent.close();
});
}