formatted document

Author: dshukertjr

packages/supabase_flutter/test/lifecycle_test.dart

@@ -25,56 +25,62 @@ void main() {
       }
     });
 
-    test('onResumed handles realtime reconnection when channels exist', () async {
+    test('onResumed handles realtime reconnection when channels exist',
+        () async {
       await Supabase.initialize(
         url: supabaseUrl,
         anonKey: supabaseKey,
       );
 
       final supabase = Supabase.instance;
-      
+
       // Create a mock channel to simulate having active channels
       final channel = supabase.client.realtime.channel('test-channel');
-      
+
       // Simulate app lifecycle state changes
       supabase.didChangeAppLifecycleState(AppLifecycleState.paused);
-      
+
       // Verify realtime was disconnected
       expect(supabase.client.realtime.connState, isNot(SocketStates.open));
-      
+
       // Simulate app resuming
       supabase.didChangeAppLifecycleState(AppLifecycleState.resumed);
-      
+
       // The onResumed method should be called
       expect(supabase.client.realtime, isNotNull);
-      
+
       // Clean up
       await channel.unsubscribe();
     });
 
-    test('didChangeAppLifecycleState handles different lifecycle states', () async {
+    test('didChangeAppLifecycleState handles different lifecycle states',
+        () async {
       await Supabase.initialize(
         url: supabaseUrl,
         anonKey: supabaseKey,
       );
 
       final supabase = Supabase.instance;
-      
+
       // Test paused state
-      expect(() => supabase.didChangeAppLifecycleState(AppLifecycleState.paused), 
-             returnsNormally);
-      
+      expect(
+          () => supabase.didChangeAppLifecycleState(AppLifecycleState.paused),
+          returnsNormally);
+
       // Test detached state
-      expect(() => supabase.didChangeAppLifecycleState(AppLifecycleState.detached), 
-             returnsNormally);
-      
+      expect(
+          () => supabase.didChangeAppLifecycleState(AppLifecycleState.detached),
+          returnsNormally);
+
       // Test resumed state
-      expect(() => supabase.didChangeAppLifecycleState(AppLifecycleState.resumed), 
-             returnsNormally);
-      
+      expect(
+          () => supabase.didChangeAppLifecycleState(AppLifecycleState.resumed),
+          returnsNormally);
+
       // Test inactive state (should be handled by default case)
-      expect(() => supabase.didChangeAppLifecycleState(AppLifecycleState.inactive), 
-             returnsNormally);
+      expect(
+          () => supabase.didChangeAppLifecycleState(AppLifecycleState.inactive),
+          returnsNormally);
     });
 
     test('onResumed handles disconnecting state properly', () async {
@@ -84,18 +90,18 @@ void main() {
       );
 
       final supabase = Supabase.instance;
-      
+
       // Create a channel to ensure channels exist
       final channel = supabase.client.realtime.channel('test-channel');
-      
+
       // Simulate disconnecting state by pausing first
       supabase.didChangeAppLifecycleState(AppLifecycleState.paused);
-      
+
       // Now test resuming while in disconnecting state
       await supabase.onResumed();
-      
+
       expect(supabase.client.realtime, isNotNull);
-      
+
       // Clean up
       await channel.unsubscribe();
     });
@@ -107,15 +113,15 @@ void main() {
       );
 
       final supabase = Supabase.instance;
-      
+
       // The observer should be added during initialization
       expect(supabase, isNotNull);
-      
+
       // Dispose should remove the observer
       await supabase.dispose();
-      
+
       // After disposal, the instance should be reset
       expect(() => Supabase.instance, throwsA(isA<AssertionError>()));
     });
   });
-}
+}

packages/supabase_flutter/test/storage_test.dart

@@ -128,17 +128,18 @@ void main() {
       test('setItem overwrites existing value', () async {
         const initialValue = 'initial';
         const newValue = 'new';
-        
+
         await asyncStorage.setItem(key: testKey, value: initialValue);
         expect(await asyncStorage.getItem(key: testKey), initialValue);
-        
+
         await asyncStorage.setItem(key: testKey, value: newValue);
         expect(await asyncStorage.getItem(key: testKey), newValue);
       });
 
       test('removeItem handles non-existent key gracefully', () async {
         // Should not throw when removing a key that doesn't exist
-        expect(() => asyncStorage.removeItem(key: 'non_existent_key'), returnsNormally);
+        expect(() => asyncStorage.removeItem(key: 'non_existent_key'),
+            returnsNormally);
         await asyncStorage.removeItem(key: 'non_existent_key');
       });
     });
@@ -164,16 +165,17 @@ void main() {
       test('persistSession does nothing and returns normally', () async {
         expect(() => emptyStorage.persistSession('test'), returnsNormally);
         await emptyStorage.persistSession('test');
-        
+
         // Should still return null/false after persist attempt
         expect(await emptyStorage.hasAccessToken(), false);
         expect(await emptyStorage.accessToken(), null);
       });
 
-      test('removePersistedSession does nothing and returns normally', () async {
+      test('removePersistedSession does nothing and returns normally',
+          () async {
         expect(() => emptyStorage.removePersistedSession(), returnsNormally);
         await emptyStorage.removePersistedSession();
-        
+
         // Should still return null/false after remove attempt
         expect(await emptyStorage.hasAccessToken(), false);
         expect(await emptyStorage.accessToken(), null);
@@ -187,7 +189,7 @@ void main() {
           persistSessionKey: 'test_empty_session',
         );
         await localStorage.initialize();
-        
+
         await localStorage.persistSession('');
         expect(await localStorage.hasAccessToken(), true);
         expect(await localStorage.accessToken(), '');
@@ -198,8 +200,9 @@ void main() {
           persistSessionKey: 'test_special_chars',
         );
         await localStorage.initialize();
-        
-        const specialSession = '{"access_token": "áéíóú-test-token-!@#\$%^&*()"}';
+
+        const specialSession =
+            '{"access_token": "áéíóú-test-token-!@#\$%^&*()"}';
         await localStorage.persistSession(specialSession);
         expect(await localStorage.hasAccessToken(), true);
         expect(await localStorage.accessToken(), specialSession);
@@ -210,16 +213,16 @@ void main() {
           persistSessionKey: 'test_multiple_ops',
         );
         await localStorage.initialize();
-        
+
         // Multiple persist operations
         await localStorage.persistSession('session1');
         await localStorage.persistSession('session2');
         expect(await localStorage.accessToken(), 'session2');
-        
+
         // Remove then add again
         await localStorage.removePersistedSession();
         expect(await localStorage.hasAccessToken(), false);
-        
+
         await localStorage.persistSession('session3');
         expect(await localStorage.accessToken(), 'session3');
       });