Fixed 4 critical bugs found during code review:

- Added missing await keywords in addOrUpdate() switch statement
- Changed int.parse() to int.tryParse() in secure storage
- Fixed null pointer when reading non-existent List<Map> from preferences
- Fixed typo: enalbeLogging → enableLogging

Author: chadpav

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.0.6
+
+* **CRITICAL BUG FIX**: Added missing `await` keywords in `addOrUpdate()` switch statement - ensures async operations complete before returning
+* **CRITICAL BUG FIX**: Changed `int.parse()` to `int.tryParse()` in secure storage to prevent exceptions on missing keys
+* **CRITICAL BUG FIX**: Fixed null pointer exception when reading non-existent `List<Map<String, dynamic>>` from preferences
+* Fixed typo: renamed `enalbeLogging` parameter to `enableLogging` in factory method
+
 ## 0.0.5
 
 * Added support for web platform using shared preferences

lib/flutter_easy_cache.dart

@@ -41,9 +41,9 @@ class FlutterEasyCache {
         _preferences = preferences;
 
   factory FlutterEasyCache.create(SharedPreferencesWithCache preferences, FlutterSecureStorage secureStorage,
-      {bool enalbeLogging = false}) {
+      {bool enableLogging = false}) {
     return FlutterEasyCache._internal(
-        preferences: preferences, secureStorage: secureStorage, loggingEnabled: enalbeLogging);
+        preferences: preferences, secureStorage: secureStorage, loggingEnabled: enableLogging);
   }
 
   /// Add a value to cache, replacing any existing value
@@ -57,11 +57,11 @@ class FlutterEasyCache {
 
     switch (policy) {
       case CachePolicy.appSession:
-        _addOrUpdateAppSession<T>(key: key, value: value);
+        await _addOrUpdateAppSession<T>(key: key, value: value);
       case CachePolicy.appInstall:
-        _addOrUpdateAppInstall<T>(key: key, value: value);
+        await _addOrUpdateAppInstall<T>(key: key, value: value);
       case CachePolicy.secure:
-        _addOrUpdateSecureStorage<T>(key: key, value: value);
+        await _addOrUpdateSecureStorage<T>(key: key, value: value);
         break;
     }
   }
@@ -195,8 +195,10 @@ class FlutterEasyCache {
       } else if (T == List<String>) {
         value = _preferences?.getStringList(key) as T?;
       } else if (T == List<Map<String, dynamic>>) {
-        final stringList = _preferences?.getStringList(key) as List<String>;
-        value = stringList.map((e) => jsonDecode(e) as Map<String, dynamic>).toList() as T?;
+        final stringList = _preferences?.getStringList(key);
+        if (stringList != null) {
+          value = stringList.map((e) => jsonDecode(e) as Map<String, dynamic>).toList() as T?;
+        }
       }
     } catch (e) {
       _consolePrint('WARN: EasyCache error getting "$key": "$e"');
@@ -224,7 +226,7 @@ class FlutterEasyCache {
         value = bool.tryParse(stringValue ?? '', caseSensitive: false) as T?;
       } else if (T == int) {
         final stringValue = await _secureStorage?.read(key: key);
-        value = int.parse(stringValue ?? '') as T?;
+        value = int.tryParse(stringValue ?? '') as T?;
       } else if (T == double) {
         final stringValue = await _secureStorage?.read(key: key);
         value = double.tryParse(stringValue ?? '') as T?;

pubspec.yaml

@@ -1,6 +1,6 @@
 name: flutter_easy_cache
 description: "A don't overthink it, easy-to-use caching layer for Flutter."
-version: 0.0.5
+version: 0.0.6
 repository: https://github.com/chadpavliska/flutter_easy_cache
 
 environment:

test/bug_reproduction_test.dart

@@ -0,0 +1,99 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_easy_cache/flutter_easy_cache.dart';
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+/// These tests are designed to expose specific bugs found in code review
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  late FlutterEasyCache cache;
+  SharedPreferencesWithCache? sharedPreferences;
+  FlutterSecureStorage? secureStorage;
+
+  setUp(() async {
+    FlutterEasyCache.setMockInitialValues();
+    secureStorage ??= const FlutterSecureStorage();
+    sharedPreferences ??=
+        await SharedPreferencesWithCache.create(cacheOptions: const SharedPreferencesWithCacheOptions());
+    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enableLogging: true);
+  });
+
+  tearDown(() async {
+    await FlutterEasyCache.resetStatic();
+  });
+
+  group('Bug Reproduction Tests', () {
+    // Bug #2: int.parse() should use tryParse() to avoid throwing
+    test('BUG #2: Reading non-existent int from secure storage should not throw FormatException', () async {
+      // First, add and then remove an int to ensure secure storage is initialized
+      await cache.addOrUpdate(key: 'tempInt', value: 42, policy: CachePolicy.secure);
+      await cache.remove(key: 'tempInt');
+
+      // Now try to read a key that was never set
+      // With int.parse(), this will throw FormatException: Invalid radix-10 number (at character 1)
+      // With int.tryParse(), this will return null gracefully
+
+      int? retrievedValue;
+      bool didThrow = false;
+
+      try {
+        retrievedValue = await cache.getValueOrNull<int>(key: 'neverSetIntKey');
+      } catch (e) {
+        didThrow = true;
+        // Exception caught: $e
+      }
+
+      expect(didThrow, false, reason: 'Should use int.tryParse() instead of int.parse() to avoid throwing');
+      expect(retrievedValue, null);
+    });
+
+    // Bug #3: Null pointer when reading non-existent List<Map>
+    test('BUG #3: Reading non-existent List<Map> from preferences should not throw', () async {
+      // Initialize preferences
+      await cache.addOrUpdate(key: 'dummy', value: 'value', policy: CachePolicy.appInstall);
+
+      // Try to read a List<Map> that doesn't exist
+      // Line 198: final stringList = _preferences?.getStringList(key) as List<String>;
+      // This will throw TypeError: Null check operator used on a null value
+
+      List<Map<String, dynamic>>? retrievedValue;
+      bool didThrow = false;
+
+      try {
+        retrievedValue = await cache.getValueOrNull<List<Map<String, dynamic>>>(key: 'neverSetListMapKey');
+      } catch (e) {
+        didThrow = true;
+        // Exception caught: $e
+      }
+
+      expect(didThrow, false, reason: 'Should check for null before casting');
+      expect(retrievedValue, null);
+    });
+
+    // Bug #1: Missing await in addOrUpdate switch statement
+    test('BUG #1: addOrUpdate should await async operations in switch statement', () async {
+      // This test tries to verify that the Future completes only after write finishes
+      // In practice, this bug might not be caught by tests due to fast execution
+      // But it violates the async contract
+
+      const value = 'test-value';
+
+      // Create a list to track execution order
+      final executionOrder = <String>[];
+
+      cache.addOrUpdate(key: 'testKey', value: value, policy: CachePolicy.appInstall).then((_) {
+        executionOrder.add('addOrUpdate completed');
+      });
+
+      // Small delay to let async operations settle
+      await Future.delayed(const Duration(milliseconds: 10));
+      executionOrder.add('after delay');
+
+      final retrievedValue = await cache.getValueOrNull<String>(key: 'testKey');
+
+      expect(retrievedValue, value);
+      expect(executionOrder, contains('addOrUpdate completed'));
+    });
+  });
+}

test/flutter_easy_cache_app_install_test.dart

@@ -21,7 +21,7 @@ void main() {
     secureStorage ??= const FlutterSecureStorage();
 
     // sut
-    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enalbeLogging: false);
+    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enableLogging: false);
   });
 
   tearDown(() async {

test/flutter_easy_cache_app_session_test.dart

@@ -21,7 +21,7 @@ void main() {
         await SharedPreferencesWithCache.create(cacheOptions: const SharedPreferencesWithCacheOptions());
 
     // sut
-    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enalbeLogging: false);
+    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enableLogging: false);
   });
 
   tearDown(() async {

test/flutter_easy_cache_secure_test.dart

@@ -21,7 +21,7 @@ void main() {
         await SharedPreferencesWithCache.create(cacheOptions: const SharedPreferencesWithCacheOptions());
 
     // sut
-    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enalbeLogging: false);
+    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enableLogging: false);
   });
 
   tearDown(() async {

test/flutter_easy_cache_test.dart

@@ -21,7 +21,7 @@ void main() {
         await SharedPreferencesWithCache.create(cacheOptions: const SharedPreferencesWithCacheOptions());
 
     // sut
-    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enalbeLogging: false);
+    cache = FlutterEasyCache.create(sharedPreferences!, secureStorage!, enableLogging: false);
   });
 
   tearDown(() async {
@@ -176,5 +176,47 @@ void main() {
         throwsA(isA<TypeError>()),
       );
     });
+
+    // TDD: Test for Bug #1 - Missing await in addOrUpdate()
+    test('addOrUpdate completes only after value is written to storage', () async {
+      const value = 'test-value';
+
+      // Write to appInstall (requires async disk write)
+      await cache.addOrUpdate(key: 'testKey', value: value, policy: CachePolicy.appInstall);
+
+      // If await is missing in the switch statement, this might read before write completes
+      final retrievedValue = await cache.getValueOrNull<String>(key: 'testKey');
+
+      expect(retrievedValue, value, reason: 'Value should be available immediately after addOrUpdate completes');
+    });
+
+    // TDD: Test for Bug #2 - int.parse() throws instead of returning null
+    test('Reading non-existent int from secure storage returns null (not throw)', () async {
+      // This should NOT throw - should return null gracefully
+      expect(
+        () async => await cache.getValueOrNull<int>(key: 'nonExistentIntKey'),
+        returnsNormally,
+        reason: 'Should not throw when reading non-existent int from secure storage',
+      );
+
+      final value = await cache.getValueOrNull<int>(key: 'nonExistentIntKey');
+      expect(value, null);
+    });
+
+    // TDD: Test for Bug #3 - Null pointer in List<Map> deserialization
+    test('Reading non-existent List<Map> from preferences returns null (not throw)', () async {
+      // First write to appInstall to ensure preferences is initialized
+      await cache.addOrUpdate(key: 'dummyKey', value: 'dummy', policy: CachePolicy.appInstall);
+
+      // This should NOT throw - should return null gracefully
+      expect(
+        () async => await cache.getValueOrNull<List<Map<String, dynamic>>>(key: 'nonExistentListMapKey'),
+        returnsNormally,
+        reason: 'Should not throw when reading non-existent List<Map> from preferences',
+      );
+
+      final value = await cache.getValueOrNull<List<Map<String, dynamic>>>(key: 'nonExistentListMapKey');
+      expect(value, null);
+    });
   });
 }