packages/shared/test/date/timezone.spec.ts

   1 import { listTimeZones } from '@protontech/timezone-support';
   2
   3 import type { SimpleMap } from '@proton/shared/lib/interfaces';
   4
   5 import {
   6     convertUTCDateTimeToZone,
   7     convertZonedDateTimeToUTC,
   8     getAbbreviatedTimezoneName,
   9     getReadableCityTimezone,
  10     getSupportedTimezone,
  11     getTimezoneAndOffset,
  12     guessTimezone,
  13 } from '../../lib/date/timezone';
  14 import { MANUAL_TIMEZONE_LINKS, unsupportedTimezoneLinks } from '../../lib/date/timezoneDatabase';
  15
  16 describe('convert utc', () => {
  17     const obj = (year: number, month: number, day: number, hours = 0, minutes = 0, seconds = 0) => ({
  18         year,
  19         month,
  20         day,
  21         hours,
  22         minutes,
  23         seconds,
  24     });
  25
  26     it('should convert a zoned time (Australia/Sydney) to utc', () => {
  27         expect(convertZonedDateTimeToUTC(obj(2019, 1, 1), 'Australia/Sydney')).toEqual(obj(2018, 12, 31, 13));
  28     });
  29
  30     it('should convert a zoned time (Europe/Zurich summer) to utc', () => {
  31         expect(convertZonedDateTimeToUTC(obj(2019, 6, 15, 1), 'Europe/Zurich')).toEqual(obj(2019, 6, 14, 23));
  32     });
  33
  34     it('should convert a zoned time (Europe/Zurich winter) to utc', () => {
  35         expect(convertZonedDateTimeToUTC(obj(2019, 12, 15, 1), 'Europe/Zurich')).toEqual(obj(2019, 12, 15, 0));
  36     });
  37
  38     it('should convert a zoned time to utc with winter-to-summer (Europe/Zurich 2017) dst shift', () => {
  39         expect(convertZonedDateTimeToUTC(obj(2017, 3, 26, 1), 'Europe/Zurich')).toEqual(obj(2017, 3, 26, 0));
  40         expect(convertZonedDateTimeToUTC(obj(2017, 3, 26, 2), 'Europe/Zurich')).toEqual(obj(2017, 3, 26, 1));
  41         expect(convertZonedDateTimeToUTC(obj(2017, 3, 26, 3), 'Europe/Zurich')).toEqual(obj(2017, 3, 26, 1));
  42         expect(convertZonedDateTimeToUTC(obj(2017, 3, 26, 4), 'Europe/Zurich')).toEqual(obj(2017, 3, 26, 2));
  43     });
  44
  45     it('should convert a zoned time to utc with summer-to-winter (Europe/Zurich 2019) dst shift', () => {
  46         expect(convertZonedDateTimeToUTC(obj(2019, 10, 27, 1), 'Europe/Zurich')).toEqual(obj(2019, 10, 26, 23));
  47         expect(convertZonedDateTimeToUTC(obj(2019, 10, 27, 2), 'Europe/Zurich')).toEqual(obj(2019, 10, 27, 1));
  48         expect(convertZonedDateTimeToUTC(obj(2019, 10, 27, 3), 'Europe/Zurich')).toEqual(obj(2019, 10, 27, 2));
  49         expect(convertZonedDateTimeToUTC(obj(2019, 10, 27, 4), 'Europe/Zurich')).toEqual(obj(2019, 10, 27, 3));
  50     });
  51
  52     it('should convert from utc time to a timezone (Australia/Sydney)', () => {
  53         expect(convertUTCDateTimeToZone(obj(2018, 12, 31, 13), 'Australia/Sydney')).toEqual(obj(2019, 1, 1));
  54     });
  55
  56     it('should convert back from a utc to a timezone (Europe/Zurich summer)', () => {
  57         expect(convertUTCDateTimeToZone(obj(2019, 6, 14, 23), 'Europe/Zurich')).toEqual(obj(2019, 6, 15, 1));
  58     });
  59
  60     it('should convert back from a utc time to a timezone (Europe/Zurich winter)', () => {
  61         expect(convertUTCDateTimeToZone(obj(2019, 12, 15, 0), 'Europe/Zurich')).toEqual(obj(2019, 12, 15, 1));
  62     });
  63
  64     it('should convert back from a utc to a timezone (Europe/Zurich 2017) with summer-to-winter dst shifts', () => {
  65         expect(convertUTCDateTimeToZone(obj(2017, 3, 26, 0), 'Europe/Zurich')).toEqual(obj(2017, 3, 26, 1));
  66         expect(convertUTCDateTimeToZone(obj(2017, 3, 26, 1), 'Europe/Zurich')).toEqual(obj(2017, 3, 26, 3));
  67         expect(convertUTCDateTimeToZone(obj(2017, 3, 26, 2), 'Europe/Zurich')).toEqual(obj(2017, 3, 26, 4));
  68     });
  69
  70     it('should convert back from a utc to a timezone (Europe/Zurich 2017) with winter-to-summer dst shifts', () => {
  71         expect(convertUTCDateTimeToZone(obj(2019, 10, 27, 0), 'Europe/Zurich')).toEqual(obj(2019, 10, 27, 2));
  72         expect(convertUTCDateTimeToZone(obj(2019, 10, 27, 1), 'Europe/Zurich')).toEqual(obj(2019, 10, 27, 2));
  73         expect(convertUTCDateTimeToZone(obj(2019, 10, 27, 2), 'Europe/Zurich')).toEqual(obj(2019, 10, 27, 3));
  74     });
  75 });
  76
  77 describe('getSupportedTimezone', () => {
  78     it('should remove extra slashes', () => {
  79         expect(getSupportedTimezone('/Europe/London/')).toEqual('Europe/London');
  80         expect(getSupportedTimezone('/Africa/Freetown/')).toEqual('Africa/Abidjan');
  81     });
  82
  83     it('should support the bluejeans format', () => {
  84         expect(getSupportedTimezone('/tzurl.org/2020b/America/Chicago')).toEqual('America/Chicago');
  85         expect(getSupportedTimezone('/tzurl.org/2020b/Asia/Istanbul')).toEqual('Europe/Istanbul');
  86     });
  87
  88     it('should support the mozilla format', () => {
  89         expect(getSupportedTimezone('/mozilla.org/20050126_1/America/Argentina/Ushuaia')).toEqual(
  90             'America/Argentina/Ushuaia'
  91         );
  92         expect(getSupportedTimezone('/mozilla.org/20050126_1/America/Argentina/ComodRivadavia')).toEqual(
  93             'America/Argentina/Catamarca'
  94         );
  95     });
  96
  97     it('should transform globally defined alias timezones according to the longest match', () => {
  98         // GB (Europe/London), Eire (Europe/Dublin) and GB-Eire (Europe/London) are all alias timezones.
  99         // getSupportedTimezone should transform according to the longest match, GB-Eire -> Europe/London
 100         expect(getSupportedTimezone('/mozilla.org/20050126_1/GB-Eire')).toEqual('Europe/London');
 101         expect(getSupportedTimezone('/tzurl.org/2021a/Eire')).toEqual('Europe/Dublin');
 102         expect(getSupportedTimezone('/GB/')).toEqual('Europe/London');
 103     });
 104
 105     it('should be robust for capturing globally defined timezones (for which no specification exists)', () => {
 106         expect(getSupportedTimezone('/IANA-db:Asia/Seoul--custom.format')).toEqual('Asia/Seoul');
 107     });
 108
 109     it('should filter non-supported canonical timezones', () => {
 110         const canonical = listTimeZones();
 111         const results = canonical.map((tzid) => getSupportedTimezone(tzid));
 112         const expected = canonical.map((tzid) => unsupportedTimezoneLinks[tzid] || tzid);
 113         expect(results).toEqual(expected);
 114     });
 115
 116     it('should return the supported canonical timezone for alias timezones', () => {
 117         const alias = [
 118             'Africa/Bujumbura',
 119             'Africa/Freetown',
 120             'America/Antigua',
 121             'America/Indianapolis',
 122             'Asia/Macao',
 123             'Asia/Istanbul',
 124             'Europe/Skopje',
 125             'GB-Eire',
 126         ];
 127         const canonical = [
 128             'Africa/Maputo',
 129             'Africa/Abidjan',
 130             'America/Puerto_Rico',
 131             'America/New_York',
 132             'Asia/Macau',
 133             'Europe/Istanbul',
 134             'Europe/Belgrade',
 135             'Europe/London',
 136         ];
 137         const results = alias.map((tzid) => getSupportedTimezone(tzid));
 138         expect(results).toEqual(canonical);
 139     });
 140
 141     it('should convert manual timezones', () => {
 142         const manual = Object.keys(MANUAL_TIMEZONE_LINKS);
 143         const results = manual.map((tzid) => getSupportedTimezone(tzid));
 144         const expected = Object.values(MANUAL_TIMEZONE_LINKS);
 145         expect(results).toEqual(expected);
 146     });
 147
 148     it('should convert time zones we do not support yet', () => {
 149         const expectedMap: SimpleMap<string> = {
 150             'Pacific/Kanton': 'Pacific/Fakaofo',
 151             'Europe/Kyiv': 'Europe/Kiev',
 152             'America/Nuuk': 'Atlantic/Stanley',
 153             'America/Ciudad_Juarez': 'America/Ojinaga',
 154         };
 155
 156         Object.keys(expectedMap).forEach((tzid) => {
 157             expect(getSupportedTimezone(tzid)).toBe(expectedMap[tzid]);
 158         });
 159     });
 160
 161     it('should convert deprecated time zones', () => {
 162         const expectedMap: SimpleMap<string> = {
 163             'Australia/Currie': 'Australia/Hobart',
 164         };
 165
 166         Object.keys(expectedMap).forEach((tzid) => {
 167             expect(getSupportedTimezone(tzid)).toBe(expectedMap[tzid]);
 168         });
 169     });
 170
 171     it('should be robust', () => {
 172         const tzids = ['Chamorro (UTC+10)', '(GMT-01:00) Azores', 'Mountain Time (U.S. & Canada)'];
 173         const expected = ['Pacific/Saipan', 'Atlantic/Azores', 'America/Denver'];
 174         const results = tzids.map(getSupportedTimezone);
 175         expect(results).toEqual(expected);
 176     });
 177
 178     it('should return undefined for unknown timezones', () => {
 179         const unknown = ['Chamorro Standard Time', '(UTC+01:00) Bruxelles, Copenhague, Madrid, Paris'];
 180         const results = unknown.map((tzid) => getSupportedTimezone(tzid));
 181         const expected = unknown.map(() => undefined);
 182         expect(results).toEqual(expected);
 183     });
 184 });
 185
 186 describe('guessTimeZone', () => {
 187     const timeZoneList = listTimeZones();
 188
 189     describe('should guess right when the browser detects "Europe/Zurich"', () => {
 190         beforeEach(() => {
 191             spyOn<any>(Intl, 'DateTimeFormat').and.returnValue({
 192                 resolvedOptions: () => ({ timeZone: 'Europe/Zurich' }),
 193             });
 194         });
 195
 196         it('guesses "Europe/Zurich"', () => {
 197             expect(guessTimezone(timeZoneList)).toBe('Europe/Zurich');
 198         });
 199     });
 200
 201     describe('should guess right when the browser detects "Europe/Kyiv"', () => {
 202         beforeEach(() => {
 203             spyOn<any>(Intl, 'DateTimeFormat').and.returnValue({
 204                 resolvedOptions: () => ({ timeZone: 'Europe/Kyiv' }),
 205             });
 206         });
 207
 208         it('guesses "Europe/Kiev"', () => {
 209             expect(guessTimezone(timeZoneList)).toBe('Europe/Kiev');
 210         });
 211     });
 212
 213     describe('should guess right when the browser detects "Pacific/Kanton"', () => {
 214         beforeEach(() => {
 215             spyOn<any>(Intl, 'DateTimeFormat').and.returnValue({
 216                 resolvedOptions: () => ({ timeZone: 'Pacific/Kanton' }),
 217             });
 218         });
 219
 220         it('guesses "Pacific/Fakaofo"', () => {
 221             expect(guessTimezone(timeZoneList)).toBe('Pacific/Fakaofo');
 222         });
 223     });
 224
 225     describe('should guess right when the browser detects unknown time zone with GMT+1', () => {
 226         beforeEach(() => {
 227             const baseTime = Date.UTC(2023, 2, 7, 9);
 228
 229             spyOn<any>(Intl, 'DateTimeFormat').and.returnValue({
 230                 resolvedOptions: () => ({ timeZone: 'unknown' }),
 231             });
 232             spyOn<any>(window, 'Date').and.returnValue({
 233                 getTime: () => baseTime,
 234                 getTimezoneOffset: () => -60,
 235                 getUTCFullYear: () => 2023,
 236                 getUTCMonth: () => 2,
 237                 getUTCDate: () => 7,
 238                 getUTCDay: () => 2,
 239                 getUTCHours: () => 9,
 240                 getUTCMinutes: () => 0,
 241                 getUTCSeconds: () => 0,
 242                 getUTCMilliseconds: () => 0,
 243             });
 244         });
 245
 246         it('guesses "Africa/Algiers", first in the list with that GMT offset', () => {
 247             expect(guessTimezone(timeZoneList)).toBe('Africa/Algiers');
 248         });
 249     });
 250 });
 251
 252 describe('getReadableCityTimezone', () => {
 253     it('should return city timezone without underscores', () => {
 254         const cityTimezone = 'Los_Angeles';
 255
 256         expect(getReadableCityTimezone(cityTimezone)).toEqual('Los Angeles');
 257     });
 258
 259     it('should return city timezone without change', () => {
 260         const cityTimezone = 'Paris';
 261
 262         expect(getReadableCityTimezone(cityTimezone)).toEqual('Paris');
 263     });
 264 });
 265
 266 describe('getAbbreviatedTimezoneName', () => {
 267     it('should return the expected offset timezone', () => {
 268         const timezone = 'Europe/Paris';
 269         const result = getAbbreviatedTimezoneName('offset', timezone) || '';
 270
 271         expect(['GMT+1', 'GMT+2']).toContain(result);
 272     });
 273
 274     it('should return the expected city timezone', () => {
 275         const timezone = 'Europe/Paris';
 276
 277         expect(getAbbreviatedTimezoneName('city', timezone)).toEqual('Paris');
 278     });
 279
 280     it('should return the expected city timezone on a readable format', () => {
 281         const timezone = 'America/Los_Angeles';
 282
 283         expect(getAbbreviatedTimezoneName('city', timezone)).toEqual('Los Angeles');
 284     });
 285
 286     it('should return the expected city timezone for a longer timezone', () => {
 287         const timezone = 'America/North_Dakota/New_Salem';
 288
 289         expect(getAbbreviatedTimezoneName('city', timezone)).toEqual('New Salem');
 290     });
 291 });
 292
 293 describe('getTimezoneAndOffset', () => {
 294     it('should return the expected timezone string, containing offset and name', () => {
 295         const timezone = 'Europe/Paris';
 296         const result = getTimezoneAndOffset(timezone);
 297
 298         expect(['GMT+1 • Europe/Paris', 'GMT+2 • Europe/Paris']).toContain(result);
 299     });
 300 });