fix: Ethernet not recognized as connectivity state

packages/dart/lib/src/network/parse_connectivity.dart

@@ -5,6 +5,9 @@ enum ParseConnectivityResult {
   /// WiFi: Device connected via Wi-Fi
   wifi,
 
+  /// Ethernet: Device connected via Ethernet
+  ethernet,
+
   /// Mobile: Device connected to cellular network
   mobile,
 

packages/dart/test/src/network/parse_live_query_test.dart

@@ -6,6 +6,30 @@ import 'package:test/test.dart';
 
 import '../../test_utils.dart';
 
+/// Mock connectivity provider for testing different connectivity states
+class MockConnectivityProvider implements ParseConnectivityProvider {
+  final StreamController<ParseConnectivityResult> _controller =
+      StreamController<ParseConnectivityResult>.broadcast();
+  ParseConnectivityResult _currentState = ParseConnectivityResult.wifi;
+
+  @override
+  Future<ParseConnectivityResult> checkConnectivity() async {
+    return _currentState;
+  }
+
+  @override
+  Stream<ParseConnectivityResult> get connectivityStream => _controller.stream;
+
+  void setConnectivity(ParseConnectivityResult state) {
+    _currentState = state;
+    _controller.add(state);
+  }
+
+  void dispose() {
+    _controller.close();
+  }
+}
+
 void main() {
   setUpAll(() async {
     // Create a fake server
@@ -62,4 +86,141 @@ void main() {
     // 10 millisecond hold for stream
     await Future.delayed(Duration(milliseconds: 10));
   });
+
+  group('Connectivity handling', () {
+    late MockConnectivityProvider mockConnectivity;
+
+    setUp(() {
+      mockConnectivity = MockConnectivityProvider();
+    });
+
+    tearDown(() {
+      mockConnectivity.dispose();
+    });
+
+    test('should handle wifi connectivity', () async {
+      // arrange
+      mockConnectivity.setConnectivity(ParseConnectivityResult.wifi);
+
+      await Parse().initialize(
+        'appId',
+        serverUrl,
+        debug: true,
+        fileDirectory: 'someDirectory',
+        appName: 'appName',
+        appPackageName: 'somePackageName',
+        appVersion: 'someAppVersion',
+        connectivityProvider: mockConnectivity,
+      );
+
+      // act
+      final result = await mockConnectivity.checkConnectivity();
+
+      // assert
+      expect(result, ParseConnectivityResult.wifi);
+    });
+
+    test('should handle ethernet connectivity', () async {
+      // arrange
+      mockConnectivity.setConnectivity(ParseConnectivityResult.ethernet);
+
+      await Parse().initialize(
+        'appId',
+        serverUrl,
+        debug: true,
+        fileDirectory: 'someDirectory',
+        appName: 'appName',
+        appPackageName: 'somePackageName',
+        appVersion: 'someAppVersion',
+        connectivityProvider: mockConnectivity,
+      );
+
+      // act
+      final result = await mockConnectivity.checkConnectivity();
+
+      // assert
+      expect(result, ParseConnectivityResult.ethernet);
+    });
+
+    test('should handle mobile connectivity', () async {
+      // arrange
+      mockConnectivity.setConnectivity(ParseConnectivityResult.mobile);
+
+      await Parse().initialize(
+        'appId',
+        serverUrl,
+        debug: true,
+        fileDirectory: 'someDirectory',
+        appName: 'appName',
+        appPackageName: 'somePackageName',
+        appVersion: 'someAppVersion',
+        connectivityProvider: mockConnectivity,
+      );
+
+      // act
+      final result = await mockConnectivity.checkConnectivity();
+
+      // assert
+      expect(result, ParseConnectivityResult.mobile);
+    });
+
+    test('should handle no connectivity', () async {
+      // arrange
+      mockConnectivity.setConnectivity(ParseConnectivityResult.none);
+
+      await Parse().initialize(
+        'appId',
+        serverUrl,
+        debug: true,
+        fileDirectory: 'someDirectory',
+        appName: 'appName',
+        appPackageName: 'somePackageName',
+        appVersion: 'someAppVersion',
+        connectivityProvider: mockConnectivity,
+      );
+
+      // act
+      final result = await mockConnectivity.checkConnectivity();
+
+      // assert
+      expect(result, ParseConnectivityResult.none);
+    });
+
+    test('should emit connectivity changes through stream', () async {
+      // arrange
+      mockConnectivity.setConnectivity(ParseConnectivityResult.wifi);
+
+      await Parse().initialize(
+        'appId',
+        serverUrl,
+        debug: true,
+        fileDirectory: 'someDirectory',
+        appName: 'appName',
+        appPackageName: 'somePackageName',
+        appVersion: 'someAppVersion',
+        connectivityProvider: mockConnectivity,
+      );
+
+      final List<ParseConnectivityResult> emittedStates = [];
+      final subscription = mockConnectivity.connectivityStream.listen((state) {
+        emittedStates.add(state);
+      });
+
+      // act
+      mockConnectivity.setConnectivity(ParseConnectivityResult.ethernet);
+      await Future.delayed(Duration(milliseconds: 10));
+      mockConnectivity.setConnectivity(ParseConnectivityResult.mobile);
+      await Future.delayed(Duration(milliseconds: 10));
+      mockConnectivity.setConnectivity(ParseConnectivityResult.none);
+      await Future.delayed(Duration(milliseconds: 10));
+
+      // assert
+      expect(emittedStates.length, 3);
+      expect(emittedStates[0], ParseConnectivityResult.ethernet);
+      expect(emittedStates[1], ParseConnectivityResult.mobile);
+      expect(emittedStates[2], ParseConnectivityResult.none);
+
+      await subscription.cancel();
+    });
+  });
 }