refactor: JsonCacheSafeLocalStorage functionalities

Author: Kinpert

lib/json_cache.dart

@@ -10,6 +10,7 @@ export 'src/json_cache_hive.dart';
 export 'src/json_cache_hollow.dart';
 export 'src/json_cache_local_storage.dart';
 export 'src/json_cache_mem.dart';
+export 'src/json_cache_safe_local_storage.dart';
 export 'src/json_cache_shared_preferences.dart';
 export 'src/json_cache_try.dart';
 export 'src/json_cache_wrap.dart';

lib/src/json_cache_safe_local_storage.dart

@@ -19,26 +19,32 @@ class JsonCacheSafeLocalStorage implements JsonCache {
 
   @override
   Future<bool> contains(String key) async {
-    final item = await _localStorage.read();
-    return item[key] != null;
+    return (await _cachedData).containsKey(key);
   }
 
   @override
   Future<void> refresh(String key, Map<String, dynamic> value) async {
-    final data = {key: value};
-    await _localStorage.write(data);
+    final dataCopied = Map<dynamic, dynamic>.of(await _cachedData);
+    dataCopied[key] = value;
+    await _localStorage.write(dataCopied);
   }
 
   @override
   Future<void> remove(String key) async {
-    final data = await _localStorage.read() as Map<String, dynamic>;
-    data.removeWhere((keyMap, valueMap) => keyMap == key);
-    await _localStorage.write(data);
+    final data = await _cachedData;
+    if (data.containsKey(key)) {
+      data.remove(key);
+      await _localStorage.write(data);
+    }
   }
 
   @override
   Future<Map<String, dynamic>?> value(String key) async {
-    final data = await _localStorage.read();
-    return data[key] == null ? null : data[key] as Map<String, dynamic>;
+    return (await _cachedData)[key] as Map<String, dynamic>?;
+  }
+
+  /// Gets the cached data stored in the local storage file.
+  Future<Map<dynamic, dynamic>> get _cachedData async {
+    return await _localStorage.read() as Map<dynamic, dynamic>;
   }
 }

test/json_cache_safe_local_storage_test.dart

@@ -40,53 +40,91 @@ void main() {
     'JsonCacheSafeLocalStorage',
     () {
       test(
-        'refresh, value, clear, refresh',
+        '"refresh", "value", "remove" with one piece of data',
         () async {
+          // Insert a single piece of data into the cache
           await jsonCacheSafeLocalStorage.refresh(profKey, profData);
 
-          final data = await jsonCacheSafeLocalStorage.value(profKey);
-          expect(data, profData);
-          await jsonCacheSafeLocalStorage.clear();
+          // Check if the data has been inserted into the cache.
+          final profileRetrieved =
+              await jsonCacheSafeLocalStorage.value(profKey);
+          expect(profileRetrieved, equals(profData));
+
+          // Remove the single piece of data stored.
+          await jsonCacheSafeLocalStorage.remove(profKey);
 
-          final cleanCache = await jsonCacheSafeLocalStorage.value(profKey);
-          expect(cleanCache, isNull);
+          // No data should remain in the cache.
+          final cachedValue = await jsonCacheSafeLocalStorage.value(profKey);
+          expect(cachedValue, isNull);
         },
       );
 
       test(
-        'contains',
+        '"refresh", "value", "remove" with multiple data',
         () async {
-          // Adding content on cache. Each 'refresh' method overrides the last one.
+          // Insert multiple data into the cache
           await jsonCacheSafeLocalStorage.refresh(profKey, profData);
           await jsonCacheSafeLocalStorage.refresh(prefKey, prefData);
 
-          // Returning true if the last content exists on cache based on 'prefKey'.
-          expect(await jsonCacheSafeLocalStorage.contains(prefKey), true);
-          expect(await jsonCacheSafeLocalStorage.contains(profKey), false);
+          // Check if multiple data has been inserted into the cache.
+          final profileRetrieved =
+              await jsonCacheSafeLocalStorage.value(profKey);
+          expect(profileRetrieved, equals(profData));
+
+          final preferencesRetrived =
+              await jsonCacheSafeLocalStorage.value(prefKey);
+          expect(preferencesRetrived, prefData);
 
+          // Remove data from the cache.
+          await jsonCacheSafeLocalStorage.remove(profKey);
+          await jsonCacheSafeLocalStorage.remove(prefKey);
+
+          final removedProfValue =
+              await jsonCacheSafeLocalStorage.value(profKey);
+          expect(removedProfValue, isNull);
+          final removedPrefValue =
+              await jsonCacheSafeLocalStorage.value(prefKey);
+          expect(removedPrefValue, isNull);
+        },
+      );
+
+      test(
+        'contains',
+        () async {
+          // Insert a single piece of data into the cache.
           await jsonCacheSafeLocalStorage.refresh(profKey, profData);
-          // Returning true if the last content exists on cache based on 'profKey'.
+
+          // Check
           expect(await jsonCacheSafeLocalStorage.contains(profKey), true);
           expect(await jsonCacheSafeLocalStorage.contains(prefKey), false);
 
           // Test for keys that doesn't exist
           expect(await jsonCacheSafeLocalStorage.contains('generickey'), false);
           expect(await jsonCacheSafeLocalStorage.contains('PROFKEY'), false);
           expect(await jsonCacheSafeLocalStorage.contains('PREFKEY'), false);
+
+          // Insert a new piece of data into the cache to test more than one key stored.
+          await jsonCacheSafeLocalStorage.refresh(prefKey, prefData);
+
+          // Check for multiple data.
+          expect(await jsonCacheSafeLocalStorage.contains(profKey), true);
+          expect(await jsonCacheSafeLocalStorage.contains(prefKey), true);
         },
       );
 
       test(
-        'remove',
+        'clear',
         () async {
+          // Insert multiple data into the cache.
           await jsonCacheSafeLocalStorage.refresh(profKey, profData);
+          await jsonCacheSafeLocalStorage.refresh(prefKey, prefData);
 
-          final recoveredData = await jsonCacheSafeLocalStorage.value(profKey);
-          expect(recoveredData, profData);
+          // Clear it.
+          await jsonCacheSafeLocalStorage.clear();
 
-          await jsonCacheSafeLocalStorage.remove(profKey);
-          final cleanCache = await jsonCacheSafeLocalStorage.value(profKey);
-          expect(cleanCache, isNull);
+          // No data should remain in the cache.
+          final cachedValue = await jsonCacheSafeLocalStorage.value(profKey);
+          expect(cachedValue, isNull);
         },
       );
     },