fix: ParseInstallation saves timeZone field as empty string

packages/dart/lib/src/objects/parse_installation.dart

@@ -95,20 +95,37 @@ class ParseInstallation extends ParseObject {
 
   String _getNameLocalTimeZone() {
     tz.initializeTimeZones();
-    var locations = tz.timeZoneDatabase.locations;
 
-    Duration offset = DateTime.now().timeZoneOffset;
-    String name = "";
+    // Capture once to avoid a DST-transition race between the two reads.
+    final DateTime now = DateTime.now();
 
-    locations.forEach((key, value) {
-      for (var element in value.zones) {
-        if (element.offset == offset) {
-          name = value.name;
-          break;
-        }
+    // Prefer the OS-reported zone name when it's a valid IANA location
+    // (e.g. "America/New_York" on macOS/Linux/iOS/Android). Avoids the
+    // ambiguity of matching by offset, where many zones share an offset.
+    final String systemName = now.timeZoneName;
+    if (tz.timeZoneDatabase.locations.containsKey(systemName)) {
+      return systemName;
+    }
+
+    // Fall back to a location whose *current* zone matches the local
+    // offset. The previous implementation scanned every historical zone
+    // (LMT, pre-DST, etc.) and compared a Duration against an int offset,
+    // which on timezone <0.11.0 is always false and produced "".
+    final int localOffsetMs = now.timeZoneOffset.inMilliseconds;
+    for (final location in tz.timeZoneDatabase.locations.values) {
+      final dynamic zoneOffset = location.currentTimeZone.offset;
+      final int zoneOffsetMs = zoneOffset is Duration
+          ? zoneOffset.inMilliseconds
+          : zoneOffset as int;
+      if (zoneOffsetMs == localOffsetMs) {
+        return location.name;
       }
-    });
-    return name;
+    }
+
+    // Last resort: return whatever the OS gave us rather than "".
+    // Note: on Windows/Web this may be a non-IANA name (e.g.
+    // "Pacific Standard Time" or "EDT"), but it's still better than "".
+    return systemName;
   }
 
   @override

packages/dart/test/parse_installation_test.dart

@@ -1,30 +1,78 @@
 import 'package:parse_server_sdk/parse_server_sdk.dart';
 import 'package:test/test.dart';
+import 'package:timezone/data/latest.dart' as tz;
+import 'package:timezone/timezone.dart' as tz;
+
+Future<void> _initParse() => Parse().initialize(
+  'appId',
+  'https://example.com',
+  debug: true,
+  fileDirectory: 'someDirectory',
+  appName: 'appName',
+  appPackageName: 'somePackageName',
+  appVersion: 'someAppVersion',
+);
 
 void main() {
-  test('should return true for exist TimeZone.', () async {
-    // arrange
-    await Parse().initialize(
-      'appId',
-      'https://example.com',
-      debug: true,
-      // to prevent automatic detection
-      fileDirectory: 'someDirectory',
-      // to prevent automatic detection
-      appName: 'appName',
-      // to prevent automatic detection
-      appPackageName: 'somePackageName',
-      // to prevent automatic detection
-      appVersion: 'someAppVersion',
+  setUpAll(() async {
+    await _initParse();
+  });
+
+  test('installation has a timeZone field', () async {
+    final installation = await ParseInstallation.currentInstallation();
+    expect(installation.containsKey(keyTimeZone), isTrue);
+  });
+
+  // Regression: the SDK previously compared `int == Duration` when matching
+  // offsets against the timezone database. On timezone <0.11.0 that's always
+  // false, so the timeZone field was persisted as "". See
+  // _getNameLocalTimeZone() in parse_installation.dart.
+  test('installation timeZone is not empty', () async {
+    final installation = await ParseInstallation.currentInstallation();
+    final tzValue = installation.get<String>(keyTimeZone);
+    expect(tzValue, isNotNull);
+    expect(
+      tzValue,
+      isNotEmpty,
+      reason: 'Regression: timeZone was being stored as "".',
+    );
+  });
+
+  test('installation timeZone is an IANA name or the OS-reported name',
+      () async {
+    tz.initializeTimeZones();
+    final installation = await ParseInstallation.currentInstallation();
+    final tzValue = installation.get<String>(keyTimeZone)!;
+
+    final bool isIana = tz.timeZoneDatabase.locations.containsKey(tzValue);
+    final bool matchesSystem = tzValue == DateTime.now().timeZoneName;
+
+    expect(
+      isIana || matchesSystem,
+      isTrue,
+      reason:
+          'timeZone "$tzValue" should be an IANA zone or the OS-reported '
+          'name (fallback for Windows/Web).',
     );
+  });
+
+  test('when timeZone is matched via offset, its offset equals the local offset',
+      () async {
+    tz.initializeTimeZones();
+    final installation = await ParseInstallation.currentInstallation();
+    final tzValue = installation.get<String>(keyTimeZone)!;
 
-    // act
-    final ParseInstallation installation =
-        await ParseInstallation.currentInstallation();
+    final location = tz.timeZoneDatabase.locations[tzValue];
+    if (location == null) {
+      // OS-reported, non-IANA fallback (Windows/Web). Nothing to verify.
+      return;
+    }
 
-    dynamic actualHasTimeZoneResult = installation.containsKey(keyTimeZone);
+    final dynamic zoneOffset = location.currentTimeZone.offset;
+    final int zoneOffsetMs = zoneOffset is Duration
+        ? zoneOffset.inMilliseconds
+        : zoneOffset as int;
 
-    // assert
-    expect(actualHasTimeZoneResult, true);
+    expect(zoneOffsetMs, equals(DateTime.now().timeZoneOffset.inMilliseconds));
   });
 }