From 13184a90536b7fa5bcc8137d61f27cf238c04ace Mon Sep 17 00:00:00 2001 From: mehmetbahadirgungor Date: Tue, 3 Nov 2026 12:23:22 +0300 Subject: [PATCH 1/2] fix: make JSON cache metadata writes transactional --- flutter_cache_manager/CHANGELOG.md | 4 + .../lib/src/cache_store.dart | 35 ++-- .../json_cache_info_repository.dart | 160 +++++++++-------- flutter_cache_manager/pubspec.yaml | 2 +- .../test/json_persistence_failure_test.dart | 101 +++++++++++ .../json_file_repository_test.dart | 57 +++--- .../json_persistence_transaction_test.dart | 163 ++++++++++++++++++ 7 files changed, 394 insertions(+), 128 deletions(-) create mode 100644 flutter_cache_manager/test/json_persistence_failure_test.dart create mode 100644 flutter_cache_manager/test/repositories/json_persistence_transaction_test.dart diff --git a/flutter_cache_manager/CHANGELOG.md b/flutter_cache_manager/CHANGELOG.md index 17cf8c85..e97b6a52 100644 --- a/flutter_cache_manager/CHANGELOG.md +++ b/flutter_cache_manager/CHANGELOG.md @@ -1,3 +1,7 @@ +## [3.4.9] - 2026-11-03 + +* Fixes JSON cache metadata consistency when persistence fails. + ## [3.4.8] - 2026-11-02 * Uses the URL's file extension when a download's content type is missing or generic, such as `application/octet-stream` or `binary/octet-stream` ([#489](https://github.com/Baseflow/flutter_cache_manager/issues/489)). diff --git a/flutter_cache_manager/lib/src/cache_store.dart b/flutter_cache_manager/lib/src/cache_store.dart index 67fad4c8..92e140c6 100644 --- a/flutter_cache_manager/lib/src/cache_store.dart +++ b/flutter_cache_manager/lib/src/cache_store.dart @@ -55,24 +55,11 @@ class CacheStore { } Future putFile(CacheObject cacheObject) async { - final previousCacheObject = _memCache[cacheObject.key]; - _memCache[cacheObject.key] = cacheObject; - final dynamic out; - try { - out = await _updateCacheDataInDatabase(cacheObject); - } catch (e) { - if (previousCacheObject != null) { - _memCache[cacheObject.key] = previousCacheObject; - } else { - _memCache.remove(cacheObject.key); - } - rethrow; - } - - // We update the cache object with the id if returned by the repository - if (out is CacheObject && out.id != null) { - _memCache[cacheObject.key] = cacheObject.copyWith(id: out.id); - } + final out = await _updateCacheDataInDatabase(cacheObject); + // Do not expose a replacement in memory before its metadata is persisted. + _memCache[cacheObject.key] = out is CacheObject && out.id != null + ? cacheObject.copyWith(id: out.id) + : cacheObject; } Future retrieveCacheData( @@ -152,10 +139,7 @@ class CacheStore { final data = await provider.get(key); if (await _fileExists(data)) { unawaited( - _updateCacheDataInDatabase(data!).catchError(( - Object e, - StackTrace s, - ) { + _touchCacheData(provider, data!).catchError((Object e, StackTrace s) { cacheLogger.log( 'CacheStore: Failed to update cache metadata for $key with error:\n$e\n$s', CacheManagerLogLevel.warning, @@ -175,6 +159,13 @@ class CacheStore { } } + Future _touchCacheData( + CacheInfoRepository provider, + CacheObject data, + ) => provider is JsonCacheInfoRepository + ? provider.touch(data.key) + : provider.updateOrInsert(data); + void _scheduleCleanup() { if (_scheduledCleanup != null) { return; diff --git a/flutter_cache_manager/lib/src/storage/cache_info_repositories/json_cache_info_repository.dart b/flutter_cache_manager/lib/src/storage/cache_info_repositories/json_cache_info_repository.dart index 5d24b24a..babf9777 100644 --- a/flutter_cache_manager/lib/src/storage/cache_info_repositories/json_cache_info_repository.dart +++ b/flutter_cache_manager/lib/src/storage/cache_info_repositories/json_cache_info_repository.dart @@ -31,7 +31,6 @@ class JsonCacheInfoRepository extends CacheInfoRepository final Map _cacheObjects = {}; final Map> _jsonCache = {}; - bool _dirty = false; Future _writeQueue = Future.value(); @override @@ -64,12 +63,11 @@ class JsonCacheInfoRepository extends CacheInfoRepository if (cacheObject.id != null) { throw ArgumentError("Inserted objects shouldn't have an existing id."); } - final keys = _jsonCache.keys; - final lastId = keys.isEmpty ? 0 : keys.reduce(max); - final id = lastId + 1; - - cacheObject = cacheObject.copyWith(id: id); - return _put(cacheObject, setTouchedToNow); + return _enqueue(() async { + final keys = _jsonCache.keys; + final id = (keys.isEmpty ? 0 : keys.reduce(max)) + 1; + return _put(cacheObject.copyWith(id: id), setTouchedToNow); + }); } @override @@ -80,10 +78,18 @@ class JsonCacheInfoRepository extends CacheInfoRepository if (cacheObject.id == null) { throw ArgumentError('Updated objects should have an existing id.'); } - await _put(cacheObject, setTouchedToNow); - return 1; + return _enqueue(() async { + await _put(cacheObject, setTouchedToNow); + return 1; + }); } + /// Updates the access time of the current entry without writing a stale path. + Future touch(String key) => _enqueue(() async { + final current = _cacheObjects[key]; + if (current != null) await _put(current, true); + }); + @override Future updateOrInsert(CacheObject cacheObject) { return cacheObject.id == null ? insert(cacheObject) : update(cacheObject); @@ -106,34 +112,34 @@ class JsonCacheInfoRepository extends CacheInfoRepository } @override - Future delete(int id) async { - if (!_removeById(id)) { - return 0; - } - await _schedulePersist(); - return 1; - } + Future delete(int id) => deleteAll([id]); @override - Future deleteAll(Iterable ids) async { - var deleted = 0; - for (final id in ids) { - if (_removeById(id)) deleted++; - } - if (deleted > 0) { - await _schedulePersist(); - } - return deleted; + Future deleteAll(Iterable ids) { + final requestedIds = ids.toSet(); + return _enqueue(() async { + final nextObjects = Map.of(_cacheObjects); + final nextJson = Map>.of(_jsonCache); + var deleted = 0; + for (final id in requestedIds) { + final object = nextObjects.values.firstWhereOrNull( + (item) => item.id == id, + ); + if (object != null) { + nextObjects.remove(object.key); + nextJson.remove(id); + deleted++; + } + } + if (deleted > 0) await _commit(nextObjects, nextJson); + return deleted; + }); } @override Future close() async { final shouldCloseRepo = shouldClose(); - if (_dirty) { - await _schedulePersist(); - } else { - await _writeQueue; - } + await _writeQueue; return shouldCloseRepo; } @@ -172,65 +178,57 @@ class JsonCacheInfoRepository extends CacheInfoRepository bool setTouchedToNow, ) async { final map = cacheObject.toMap(setTouchedToNow: setTouchedToNow); - _jsonCache[cacheObject.id!] = map; - final updatedCacheObject = CacheObject.fromMap(map); - _cacheObjects[cacheObject.key] = updatedCacheObject; - await _schedulePersist(); - return updatedCacheObject; + final updated = CacheObject.fromMap(map); + final nextObjects = Map.of(_cacheObjects) + ..[updated.key] = updated; + final nextJson = Map>.of(_jsonCache) + ..[updated.id!] = map; + await _commit(nextObjects, nextJson); + return updated; } - bool _removeById(int id) { - final cacheObject = _cacheObjects.values.firstWhereOrNull( - (element) => element.id == id, + /// Each operation derives its snapshot from the last successful operation. + /// The recovery future keeps a failure from poisoning later queued writes; + /// the operation's own future still reports its error to its caller. + Future _enqueue(Future Function() operation) { + final result = _writeQueue.then((_) => operation()); + _writeQueue = result.then( + (_) {}, + onError: (Object _, StackTrace _) {}, ); - if (cacheObject == null) { - return false; - } - _cacheObjects.remove(cacheObject.key); - _jsonCache.remove(cacheObject.id); - return true; - } - - /// Queues a write of the current cache info. - /// - /// The returned future completes when the changes are on disk. Changes made - /// while a write is in progress are written by that same write or the one - /// directly after it, so a burst of changes doesn't cause a write per change. - Future _schedulePersist() { - _dirty = true; - _writeQueue = _writeQueue.then((_) => _flushIfDirty()); - return _writeQueue; + return result; } - Future _flushIfDirty() async { - while (_dirty) { - _dirty = false; - try { - await _saveFile(); - } on Object catch (e, stacktrace) { - // Keep the changes dirty so a later change or close retries the write, - // but stop here to avoid retrying a persistent failure in a loop. - _dirty = true; - FlutterError.reportError( - FlutterErrorDetails( - exception: e, - stack: stacktrace, - library: 'flutter cache manager', - context: ErrorDescription( - 'Thrown when writing the file containing cache info. ' - 'The cache info could not be persisted and may be lost when the ' - 'app is closed.', - ), + Future _commit( + Map nextObjects, + Map> nextJson, + ) async { + try { + await _saveFile(nextJson); + } on Object catch (error, stack) { + FlutterError.reportError( + FlutterErrorDetails( + exception: error, + stack: stack, + library: 'flutter cache manager', + context: ErrorDescription( + 'Thrown when writing the file containing cache info.', ), - ); - return; - } + ), + ); + rethrow; } + _cacheObjects + ..clear() + ..addAll(nextObjects); + _jsonCache + ..clear() + ..addAll(nextJson); } - Future _saveFile() async { + Future _saveFile(Map> snapshot) async { final file = await _getFile(); - final content = jsonEncode(_jsonCache.values.toList()); + final content = jsonEncode(snapshot.values.toList()); final tempFile = _createSiblingFile('${file.path}.tmp'); await tempFile.writeAsString(content, flush: true); await tempFile.rename(file.path); @@ -249,7 +247,7 @@ class JsonCacheInfoRepository extends CacheInfoRepository } @override - Future deleteDataFile() async { + Future deleteDataFile() => _enqueue(() async { final file = await _getFile(); if (await file.exists()) { await file.delete(); @@ -258,7 +256,7 @@ class JsonCacheInfoRepository extends CacheInfoRepository if (await tempFile.exists()) { await tempFile.delete(); } - } + }); @override Future exists() async { diff --git a/flutter_cache_manager/pubspec.yaml b/flutter_cache_manager/pubspec.yaml index 9726adbd..9abc0c48 100644 --- a/flutter_cache_manager/pubspec.yaml +++ b/flutter_cache_manager/pubspec.yaml @@ -1,6 +1,6 @@ name: flutter_cache_manager description: Generic cache manager for flutter. Saves web files on the storages of the device and saves the cache info using sqflite. -version: 3.4.8 +version: 3.4.9 homepage: https://github.com/Baseflow/flutter_cache_manager topics: - cache diff --git a/flutter_cache_manager/test/json_persistence_failure_test.dart b/flutter_cache_manager/test/json_persistence_failure_test.dart new file mode 100644 index 00000000..bfeb1ea4 --- /dev/null +++ b/flutter_cache_manager/test/json_persistence_failure_test.dart @@ -0,0 +1,101 @@ +import 'package:file/memory.dart'; +import 'package:flutter/foundation.dart'; +import 'package:flutter_cache_manager/flutter_cache_manager.dart'; +import 'package:flutter_test/flutter_test.dart'; + +import 'helpers/mock_file_service.dart'; +import 'helpers/test_configuration.dart'; + +void main() { + test( + 'replacement retains the old file if JSON metadata cannot persist', + () async { + final disk = MemoryFileSystem(); + final repo = JsonCacheInfoRepository.withFile( + disk.file('/metadata.json'), + ); + final manager = CacheManager( + Config( + 'repro', + repo: repo, + fileSystem: TestFileSystem(), + fileService: MockFileService(), + ), + ); + const url = 'https://example.test/report.pdf'; + final old = (await manager.webHelper.downloadFile(url).toList()) + .whereType() + .single + .file; + await disk.directory('/metadata.json.tmp').create(); + final originalHandler = FlutterError.onError; + final errors = []; + FlutterError.onError = errors.add; + try { + Object? error; + try { + await manager.webHelper + .downloadFile(url, ignoreMemCache: true) + .toList(); + } on Object catch (e) { + error = e; + } + expect( + await old.exists(), + isTrue, + reason: + 'a failed metadata write must not delete the previous cached file', + ); + expect( + error, + isNotNull, + reason: 'persistence failures must be reported', + ); + expect(errors, hasLength(1)); + final originalMetadata = await repo.get(url); + expect(old.path, endsWith(originalMetadata!.relativePath)); + expect((await manager.getFileFromCache(url))!.file.path, old.path); + expect((await old.parent.list().toList()).length, 1); + await disk.directory('/metadata.json.tmp').delete(); + await repo.insert( + CacheObject( + 'unrelated', + relativePath: 'other.file', + validTill: DateTime.now(), + ), + ); + final reloaded = JsonCacheInfoRepository.withFile( + disk.file('/metadata.json'), + ); + await reloaded.open(); + expect( + (await reloaded.get(url))!.relativePath, + originalMetadata.relativePath, + ); + expect(await old.exists(), isTrue); + await reloaded.close(); + final replacement = + (await manager.webHelper + .downloadFile(url, ignoreMemCache: true) + .toList()) + .whereType() + .single + .file; + expect(await replacement.exists(), isTrue); + expect(await old.exists(), isFalse); + final finalRepo = JsonCacheInfoRepository.withFile( + disk.file('/metadata.json'), + ); + await finalRepo.open(); + expect( + (await finalRepo.get(url))!.relativePath, + isNot(originalMetadata.relativePath), + ); + expect(await finalRepo.get('unrelated'), isNotNull); + await finalRepo.close(); + } finally { + FlutterError.onError = originalHandler; + } + }, + ); +} diff --git a/flutter_cache_manager/test/repositories/json_file_repository_test.dart b/flutter_cache_manager/test/repositories/json_file_repository_test.dart index 1daf59b6..51979124 100644 --- a/flutter_cache_manager/test/repositories/json_file_repository_test.dart +++ b/flutter_cache_manager/test/repositories/json_file_repository_test.dart @@ -258,30 +258,39 @@ void main() { expect(jsonDecode(await file.readAsString()), isA>()); }); - test('A failing write is reported and retried on close', () async { - final file = await JsonRepoHelpers.createDatabaseFile(); - final repo = JsonCacheInfoRepository.withFile(file); - await repo.open(); - - // Writing is impossible while the containing directory is gone. - await file.parent.delete(recursive: true); - - final errors = []; - final originalOnError = FlutterError.onError; - FlutterError.onError = errors.add; - await repo.insert(JsonRepoHelpers.extraCacheObject); - FlutterError.onError = originalOnError; - - expect(errors, hasLength(1)); - - await file.parent.create(recursive: true); - expect(await repo.close(), true); - - final repo2 = JsonCacheInfoRepository.withFile(file); - await repo2.open(); - final allObjects = await repo2.getAllObjects(); - expect(allObjects.length, JsonRepoHelpers.startCacheObjects.length + 1); - }); + test( + 'A failing write is reported and a later explicit retry succeeds', + () async { + final file = await JsonRepoHelpers.createDatabaseFile(); + final repo = JsonCacheInfoRepository.withFile(file); + await repo.open(); + final obstruction = file.fileSystem.directory('${file.path}.tmp'); + await obstruction.create(); + final errors = []; + final originalOnError = FlutterError.onError; + FlutterError.onError = errors.add; + try { + await expectLater( + repo.insert(JsonRepoHelpers.extraCacheObject), + throwsA(isA()), + ); + expect(errors, hasLength(1)); + expect(await repo.get(testurl4), isNull); + await obstruction.delete(); + await repo.insert(JsonRepoHelpers.extraCacheObject); + await repo.close(); + final repo2 = JsonCacheInfoRepository.withFile(file); + await repo2.open(); + expect( + (await repo2.getAllObjects()).length, + JsonRepoHelpers.startCacheObjects.length + 1, + ); + await repo2.close(); + } finally { + FlutterError.onError = originalOnError; + } + }, + ); }); } diff --git a/flutter_cache_manager/test/repositories/json_persistence_transaction_test.dart b/flutter_cache_manager/test/repositories/json_persistence_transaction_test.dart new file mode 100644 index 00000000..909b2e73 --- /dev/null +++ b/flutter_cache_manager/test/repositories/json_persistence_transaction_test.dart @@ -0,0 +1,163 @@ +import 'dart:io' show FileSystemException; + +import 'package:file/memory.dart'; +import 'package:flutter/foundation.dart'; +import 'package:flutter_cache_manager/flutter_cache_manager.dart'; +import 'package:flutter_test/flutter_test.dart'; + +void main() { + late FlutterExceptionHandler? previousHandler; + late List errors; + + setUp(() { + previousHandler = FlutterError.onError; + errors = []; + FlutterError.onError = errors.add; + }); + tearDown(() => FlutterError.onError = previousHandler); + + test('failed insert is absent after a subsequent write and reopen', () async { + final fixture = await _Fixture.create(); + fixture.failNextWrite = true; + await expectLater( + fixture.repo.insert(_object('failed')), + throwsA(isA()), + ); + expect(await fixture.repo.get('failed'), isNull); + final inserted = await fixture.repo.insert(_object('later')); + expect(inserted.id, 1); + final reopened = await fixture.reopen(); + expect(await reopened.get('failed'), isNull); + expect(await reopened.get('later'), isNotNull); + expect(errors, hasLength(1)); + }); + + test( + 'failed update never leaks into a later write or reopen; retry succeeds', + () async { + final fixture = await _Fixture.create(); + final original = await fixture.repo.insert(_object('original')); + final replacement = original.copyWith(relativePath: 'replacement.pdf'); + fixture.failNextWrite = true; + await expectLater( + fixture.repo.update(replacement), + throwsA(isA()), + ); + expect( + (await fixture.repo.get('original'))!.relativePath, + 'original.pdf', + ); + await fixture.repo.insert(_object('later')); + var reopened = await fixture.reopen(); + expect((await reopened.get('original'))!.relativePath, 'original.pdf'); + await fixture.repo.update(replacement); + reopened = await fixture.reopen(); + expect((await reopened.get('original'))!.relativePath, 'replacement.pdf'); + expect(errors, hasLength(1)); + }, + ); + + test( + 'failed delete and deleteAll retain metadata through subsequent writes', + () async { + final fixture = await _Fixture.create(); + final a = await fixture.repo.insert(_object('a')); + final b = await fixture.repo.insert(_object('b')); + fixture.failNextWrite = true; + await expectLater( + fixture.repo.delete(a.id!), + throwsA(isA()), + ); + fixture.failNextWrite = true; + await expectLater( + fixture.repo.deleteAll([a.id!, b.id!]), + throwsA(isA()), + ); + expect(await fixture.repo.get('a'), isNotNull); + expect(await fixture.repo.get('b'), isNotNull); + await fixture.repo.insert(_object('later')); + var reopened = await fixture.reopen(); + expect(await reopened.get('a'), isNotNull); + expect(await reopened.get('b'), isNotNull); + expect(await fixture.repo.deleteAll([a.id!, b.id!]), 2); + reopened = await fixture.reopen(); + expect(await reopened.get('a'), isNull); + expect(await reopened.get('b'), isNull); + expect(await reopened.get('later'), isNotNull); + expect(errors, hasLength(2)); + }, + ); + + test('overlapping queued writes recover from the first failure', () async { + final fixture = await _Fixture.create(); + fixture.failNextWrite = true; + final failed = fixture.repo.insert(_object('failed')); + final failedAssertion = expectLater( + failed, + throwsA(isA()), + ); + final succeeding = fixture.repo.insert(_object('succeeding')); + await failedAssertion; + final inserted = await succeeding; + expect(inserted.id, 1); + final reopened = await fixture.reopen(); + expect(await reopened.get('failed'), isNull); + expect((await reopened.get('succeeding'))!.id, 1); + expect(errors, hasLength(1)); + }); + + test('data-file deletion waits for an already queued write', () async { + final fixture = await _Fixture.create(); + final pending = fixture.repo.insert(_object('queued')); + final deletion = fixture.repo.deleteDataFile(); + await pending; + await deletion; + expect(await fixture.repo.exists(), isFalse); + }); + + test('queued touch uses current metadata after a replacement', () async { + final fixture = await _Fixture.create(); + final old = await fixture.repo.insert(_object('image')); + final replacement = old.copyWith(relativePath: 'replacement.png'); + final update = fixture.repo.update(replacement); + final touch = fixture.repo.touch('image'); + await Future.wait([update, touch]); + final reopened = await fixture.reopen(); + expect((await reopened.get('image'))!.relativePath, 'replacement.png'); + }); +} + +CacheObject _object(String key) => + CacheObject(key, relativePath: '$key.pdf', validTill: DateTime.utc(2030)); + +class _Fixture { + _Fixture._(); + bool failNextWrite = false; + late final MemoryFileSystem disk; + late final JsonCacheInfoRepository repo; + + static Future<_Fixture> create() async { + final fixture = _Fixture._(); + fixture.disk = MemoryFileSystem( + opHandle: (path, operation) { + if (fixture.failNextWrite && + operation == FileSystemOp.write && + path.endsWith('.tmp')) { + fixture.failNextWrite = false; + throw FileSystemException('injected write failure', path); + } + }, + ); + fixture.repo = JsonCacheInfoRepository.withFile( + fixture.disk.file('/cache.json'), + ); + await fixture.repo.open(); + return fixture; + } + + Future reopen() async { + final reopened = JsonCacheInfoRepository.withFile(disk.file('/cache.json')); + await reopened.open(); + return reopened; + } +} From 6cf5063ca55fc6005b93c13af3d6ef6963c2a906 Mon Sep 17 00:00:00 2001 From: mehmetbahadirgungor Date: Tue, 3 Nov 2026 13:01:36 +0300 Subject: [PATCH 2/2] fix: retain cached file until replacement is persisted --- flutter_cache_manager/CHANGELOG.md | 2 +- .../lib/src/web/web_helper.dart | 4 - .../test/json_persistence_failure_test.dart | 109 ++++++++++++++++++ 3 files changed, 110 insertions(+), 5 deletions(-) diff --git a/flutter_cache_manager/CHANGELOG.md b/flutter_cache_manager/CHANGELOG.md index e97b6a52..55348e74 100644 --- a/flutter_cache_manager/CHANGELOG.md +++ b/flutter_cache_manager/CHANGELOG.md @@ -1,6 +1,6 @@ ## [3.4.9] - 2026-11-03 -* Fixes JSON cache metadata consistency when persistence fails. +* Fixes JSON cache metadata consistency and preserves the previous file when replacement persistence fails. ## [3.4.8] - 2026-11-02 diff --git a/flutter_cache_manager/lib/src/web/web_helper.dart b/flutter_cache_manager/lib/src/web/web_helper.dart index 5fe120e3..084b953e 100644 --- a/flutter_cache_manager/lib/src/web/web_helper.dart +++ b/flutter_cache_manager/lib/src/web/web_helper.dart @@ -188,10 +188,6 @@ class WebHelper { var filePath = cacheObject.relativePath; if (!statusCodesFileNotChanged.contains(response.statusCode)) { - if (!filePath.endsWith(fileExtension)) { - //Delete old file directly when file extension changed - _removeOldFile(filePath); - } // Store new file on different path filePath = '${const Uuid().v1()}$fileExtension'; } diff --git a/flutter_cache_manager/test/json_persistence_failure_test.dart b/flutter_cache_manager/test/json_persistence_failure_test.dart index bfeb1ea4..ff2b945b 100644 --- a/flutter_cache_manager/test/json_persistence_failure_test.dart +++ b/flutter_cache_manager/test/json_persistence_failure_test.dart @@ -1,8 +1,13 @@ +import 'dart:async'; +import 'dart:io' show File; + import 'package:file/memory.dart'; import 'package:flutter/foundation.dart'; import 'package:flutter_cache_manager/flutter_cache_manager.dart'; import 'package:flutter_test/flutter_test.dart'; +import 'package:mockito/mockito.dart'; +import 'helpers/mock_cache_info_repository.dart'; import 'helpers/mock_file_service.dart'; import 'helpers/test_configuration.dart'; @@ -98,4 +103,108 @@ void main() { } }, ); + test( + 'failed extension-changing replacement preserves old file and metadata', + () async { + final disk = MemoryFileSystem(); + final repo = JsonCacheInfoRepository.withFile( + disk.file('/metadata.json'), + ); + final fileSystem = TestFileSystem(); + final manager = CacheManager( + Config( + 'extension-change', + repo: repo, + fileSystem: fileSystem, + fileService: MockFileService(), + ), + ); + const key = 'stable-key'; + const newUrl = 'https://example.test/new.jpg'; + final old = await fileSystem.createFile('old.png'); + final oldBytes = await File('test/images/image-120.png').readAsBytes(); + await old.writeAsBytes(oldBytes); + await manager.store.putFile( + CacheObject( + 'https://example.test/old.png', + key: key, + relativePath: 'old.png', + validTill: DateTime.utc(2030), + eTag: 'old-tag', + ), + ); + final before = await repo.get(key); + await disk.directory('/metadata.json.tmp').create(); + final previousHandler = FlutterError.onError; + final errors = []; + FlutterError.onError = errors.add; + try { + await expectLater( + manager.webHelper.downloadFile(newUrl, key: key).toList(), + throwsA(anything), + ); + expect(errors, hasLength(1)); + expect(await old.exists(), isTrue); + expect(await old.readAsBytes(), oldBytes); + final after = await repo.get(key); + expect( + after!.toMap(setTouchedToNow: false), + before!.toMap(setTouchedToNow: false), + ); + expect((await manager.getFileFromCache(key))!.file.path, old.path); + final reloaded = JsonCacheInfoRepository.withFile( + disk.file('/metadata.json'), + ); + await reloaded.open(); + expect( + (await reloaded.get(key))!.toMap(setTouchedToNow: false), + before.toMap(setTouchedToNow: false), + ); + await reloaded.close(); + expect((await old.parent.list().toList()).length, 1); + } finally { + FlutterError.onError = previousHandler; + } + }, + ); + test( + 'extension-changing replacement retains old file until persisted', + () async { + final config = createTestConfig(); + final manager = CacheManager(config); + const key = 'stable-key'; + final old = await config.fileSystem.createFile('old.png'); + final oldBytes = await File('test/images/image-120.png').readAsBytes(); + await old.writeAsBytes(oldBytes); + await manager.store.putFile( + CacheObject( + 'https://example.test/old.png', + key: key, + relativePath: 'old.png', + validTill: DateTime.utc(2030), + ), + ); + final started = Completer(); + final release = Completer(); + when( + (config.repo as MockCacheInfoRepository).updateOrInsert(any), + ).thenAnswer((_) { + started.complete(); + return release.future; + }); + final pending = manager.webHelper + .downloadFile('https://example.test/new.jpg', key: key) + .toList(); + await started.future; + expect(await old.exists(), isTrue); + expect(await old.readAsBytes(), oldBytes); + final files = await old.parent.list().toList(); + expect(files.length, 2); + release.complete(); + final result = (await pending).whereType().single; + expect(await result.file.exists(), isTrue); + expect(result.file.path, endsWith('.jpg')); + expect(await old.exists(), isFalse); + }, + ); }