packages/shared/test/calendar/valarm.spec.ts

   1 import { getIsValidAlarm, getSupportedAlarm } from '../../lib/calendar/icsSurgery/valarm';
   2 import type { VcalDateProperty, VcalValarmComponent } from '../../lib/interfaces/calendar';
   3
   4 describe('getIsValidAlarm', () => {
   5     const baseTriggerValue = { weeks: 0, days: 1, hours: 0, minutes: 0, seconds: 0, isNegative: true };
   6     const baseAlarm = {
   7         component: 'valarm',
   8         action: { value: 'DISPLAY' },
   9         trigger: { value: baseTriggerValue },
  10     } as VcalValarmComponent;
  11
  12     it('it reject alarms with unknown action', () => {
  13         const alarm = { ...baseAlarm, action: { value: 'WHATEVER' } };
  14         expect(getIsValidAlarm(alarm)).toEqual(false);
  15     });
  16
  17     it('it should reject alarms with repeat but no duration', () => {
  18         const alarm = { ...baseAlarm, repeat: { value: '1' } };
  19         expect(getIsValidAlarm(alarm)).toEqual(false);
  20     });
  21
  22     it('it should reject alarms with a malformed trigger', () => {
  23         const alarm = {
  24             ...baseAlarm,
  25             trigger: {
  26                 value: { year: 2020, month: 5, day: 2 },
  27                 parameters: { type: 'date-time' },
  28             },
  29         } as VcalValarmComponent;
  30         expect(getIsValidAlarm(alarm)).toEqual(false);
  31     });
  32 });
  33
  34 describe('getSupportedAlarm', () => {
  35     const dtstartPartDay = {
  36         value: { year: 2020, month: 5, day: 11, hours: 12, minutes: 30, seconds: 0, isUTC: true },
  37     };
  38     const dtstartAllDay = {
  39         value: { year: 2020, month: 5, day: 11 },
  40         parameters: { type: 'date' },
  41     } as VcalDateProperty;
  42     const baseTriggerValue = { weeks: 0, days: 1, hours: 0, minutes: 0, seconds: 0, isNegative: true };
  43     const baseAlarm = {
  44         component: 'valarm',
  45         action: { value: 'DISPLAY' },
  46         trigger: { value: baseTriggerValue },
  47     } as VcalValarmComponent;
  48
  49     it('it should filter out alarms with trigger related to end time', () => {
  50         const alarm = {
  51             ...baseAlarm,
  52             trigger: {
  53                 value: { ...baseTriggerValue },
  54                 parameters: { related: 'END' },
  55             },
  56         };
  57         expect(getSupportedAlarm(alarm, dtstartPartDay)).toEqual(undefined);
  58     });
  59
  60     // Duplicating EMAIL and DISPLAY to ensure both work
  61     it('it should filter out attendees, description and summary', () => {
  62         const emailAlarm = {
  63             ...baseAlarm,
  64             action: { value: 'EMAIL' },
  65             description: { value: 'test' },
  66             summary: { value: 'test' },
  67             attendee: [{ value: 'mailto:wild@west.org' }],
  68             trigger: {
  69                 value: { ...baseTriggerValue },
  70             },
  71         };
  72         const emailExpected = {
  73             ...baseAlarm,
  74             action: { value: 'EMAIL' },
  75             trigger: {
  76                 value: { ...baseTriggerValue },
  77             },
  78         };
  79         const displayAlarm = {
  80             ...baseAlarm,
  81             action: { value: 'DISPLAY' },
  82             description: { value: 'test' },
  83             summary: { value: 'test' },
  84             attendee: [{ value: 'mailto:wild@west.org' }],
  85             trigger: {
  86                 value: { ...baseTriggerValue },
  87             },
  88         };
  89         const displayExpected = {
  90             ...baseAlarm,
  91             action: { value: 'DISPLAY' },
  92             trigger: {
  93                 value: { ...baseTriggerValue },
  94             },
  95         };
  96
  97         expect(getSupportedAlarm(emailAlarm, dtstartPartDay)).toEqual(emailExpected);
  98         expect(getSupportedAlarm(displayAlarm, dtstartPartDay)).toEqual(displayExpected);
  99     });
 100
 101     it('it should filter out future notifications', () => {
 102         const alarm = {
 103             ...baseAlarm,
 104             trigger: {
 105                 value: { ...baseTriggerValue, isNegative: false },
 106             },
 107         };
 108         expect(getSupportedAlarm(alarm, dtstartPartDay)).toEqual(undefined);
 109         expect(getSupportedAlarm(alarm, dtstartAllDay)).toEqual(undefined);
 110     });
 111
 112     it('it should normalize triggers for part-day events', () => {
 113         const alarms: VcalValarmComponent[] = [
 114             {
 115                 ...baseAlarm,
 116                 trigger: {
 117                     value: { weeks: 0, days: 1, hours: 2, minutes: 1, seconds: 30, isNegative: true },
 118                 },
 119             },
 120             {
 121                 ...baseAlarm,
 122                 trigger: {
 123                     value: { year: 2020, month: 4, day: 12, hours: 9, minutes: 30, seconds: 0, isUTC: true },
 124                     parameters: { type: 'date-time' },
 125                 },
 126             },
 127         ];
 128         const expected = [
 129             {
 130                 ...baseAlarm,
 131                 trigger: {
 132                     value: { weeks: 0, days: 0, hours: 0, minutes: 1561, seconds: 0, isNegative: true },
 133                 },
 134             },
 135             {
 136                 ...baseAlarm,
 137                 trigger: {
 138                     value: { weeks: 0, days: 0, hours: 699, minutes: 0, seconds: 0, isNegative: true },
 139                 },
 140             },
 141         ];
 142         const results = alarms.map((alarm) => getSupportedAlarm(alarm, dtstartPartDay));
 143         expect(results).toEqual(expected);
 144     });
 145
 146     it('it should normalize triggers for all-day events', () => {
 147         const alarms: VcalValarmComponent[] = [
 148             {
 149                 ...baseAlarm,
 150                 trigger: {
 151                     value: { weeks: 0, days: 1, hours: 2, minutes: 1, seconds: 30, isNegative: true },
 152                 },
 153             },
 154             {
 155                 ...baseAlarm,
 156                 trigger: {
 157                     value: { year: 2020, month: 4, day: 12, hours: 9, minutes: 30, seconds: 0, isUTC: true },
 158                     parameters: { type: 'date-time' },
 159                 },
 160             },
 161         ];
 162         const expected = [
 163             {
 164                 ...baseAlarm,
 165                 trigger: {
 166                     value: { weeks: 0, days: 1, hours: 2, minutes: 1, seconds: 0, isNegative: true },
 167                 },
 168             },
 169             {
 170                 ...baseAlarm,
 171                 trigger: {
 172                     value: { weeks: 0, days: 28, hours: 14, minutes: 30, seconds: 0, isNegative: true },
 173                 },
 174             },
 175         ];
 176         const results = alarms.map((alarm) => getSupportedAlarm(alarm, dtstartAllDay));
 177         expect(results).toEqual(expected);
 178     });
 179
 180     it('it should filter out notifications out of bounds for part-day events', () => {
 181         const alarms: VcalValarmComponent[] = [
 182             {
 183                 ...baseAlarm,
 184                 trigger: {
 185                     value: { weeks: 1000, days: 1, hours: 2, minutes: 1, seconds: 30, isNegative: true },
 186                 },
 187             },
 188             {
 189                 ...baseAlarm,
 190                 trigger: {
 191                     value: { year: 1851, month: 4, day: 12, hours: 9, minutes: 30, seconds: 0, isUTC: true },
 192                     parameters: { type: 'date-time' },
 193                 },
 194             },
 195         ];
 196         const expected = alarms.map(() => undefined);
 197         const results = alarms.map((alarm) => getSupportedAlarm(alarm, dtstartPartDay));
 198         expect(results).toEqual(expected);
 199     });
 200
 201     it('it should filter out notifications out of bounds for all-day events', () => {
 202         const alarms: VcalValarmComponent[] = [
 203             {
 204                 ...baseAlarm,
 205                 trigger: {
 206                     value: { weeks: 1000, days: 1, hours: 2, minutes: 1, seconds: 30, isNegative: true },
 207                 },
 208             },
 209             {
 210                 ...baseAlarm,
 211                 trigger: {
 212                     value: { year: 1851, month: 4, day: 12, hours: 9, minutes: 30, seconds: 0, isUTC: true },
 213                     parameters: { type: 'date-time' },
 214                 },
 215             },
 216         ];
 217         const expected = alarms.map(() => undefined);
 218         const results = alarms.map((alarm) => getSupportedAlarm(alarm, dtstartAllDay));
 219         expect(results).toEqual(expected);
 220     });
 221 });