@actual-app/core 26.3.0

package/src/server/schedules/app.test.ts

@@ -0,0 +1,502 @@
+// @ts-strict-ignore
+import MockDate from 'mockdate';
+
+import { q } from '../../shared/query';
+import { getNextDate } from '../../shared/schedules';
+import { aqlQuery } from '../aql';
+import { loadMappings } from '../db/mappings';
+import { loadRules, updateRule } from '../transactions/transaction-rules';
+
+import {
+  areConditionValuesEqual,
+  createSchedule,
+  deleteSchedule,
+  setNextDate,
+  skipNextDate,
+  updateConditions,
+  updateSchedule,
+} from './app';
+
+beforeEach(async () => {
+  await global.emptyDatabase()();
+  await loadMappings();
+  await loadRules();
+});
+
+describe('schedule app', () => {
+  describe('utility', () => {
+    it('conditions are updated when they exist', () => {
+      const conds = [
+        { op: 'is', field: 'payee', value: 'FOO' },
+        { op: 'is', field: 'date', value: '2020-01-01' },
+      ];
+
+      const updated = updateConditions(conds, [
+        {
+          op: 'is',
+          field: 'payee',
+          value: 'bar',
+        },
+      ]);
+
+      expect(updated.length).toBe(2);
+      expect(updated[0].value).toBe('bar');
+    });
+
+    it("conditions are added if they don't exist", () => {
+      const conds = [
+        { op: 'contains', field: 'payee', value: 'FOO' },
+        { op: 'contains', field: 'notes', value: 'dflksjdflskdjf' },
+      ];
+
+      const updated = updateConditions(conds, [
+        {
+          op: 'is',
+          field: 'payee',
+          value: 'bar',
+        },
+      ]);
+
+      expect(updated.length).toBe(3);
+    });
+
+    it('getNextDate works with date conditions', () => {
+      expect(
+        getNextDate({ op: 'is', field: 'date', value: '2021-04-30' }),
+      ).toBe('2021-04-30');
+
+      expect(
+        getNextDate({
+          op: 'is',
+          field: 'date',
+          value: {
+            start: '2020-12-20',
+            frequency: 'monthly',
+            patterns: [
+              { type: 'day', value: 15 },
+              { type: 'day', value: 30 },
+            ],
+          },
+        }),
+      ).toBe('2020-12-30');
+    });
+
+    it('areConditionValuesEqual matches nested objects regardless of key order', () => {
+      expect(
+        areConditionValuesEqual(
+          {
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+            field: 'date',
+          },
+          {
+            field: 'date',
+            value: {
+              patterns: [
+                { value: 15, type: 'day' },
+                { value: 30, type: 'day' },
+              ],
+              frequency: 'monthly',
+              start: '2020-12-20',
+            },
+          },
+        ),
+      ).toBe(true);
+    });
+
+    it('areConditionValuesEqual returns false for different array ordering', () => {
+      expect(
+        areConditionValuesEqual(
+          [{ field: 'date' }, { field: 'account' }],
+          [{ field: 'account' }, { field: 'date' }],
+        ),
+      ).toBe(false);
+    });
+
+    it('areConditionValuesEqual distinguishes nullish values', () => {
+      expect(areConditionValuesEqual(null, undefined)).toBe(false);
+      expect(areConditionValuesEqual(undefined, undefined)).toBe(true);
+    });
+  });
+
+  describe('methods', () => {
+    it('createSchedule creates a schedule', async () => {
+      const id = await createSchedule({
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+          },
+        ],
+      });
+
+      const {
+        data: [row],
+      } = await aqlQuery(q('schedules').filter({ id }).select('*'));
+
+      expect(row).toBeTruthy();
+      expect(row.rule).toBeTruthy();
+      expect(row.next_date).toBe('2020-12-30');
+
+      await expect(
+        createSchedule({
+          conditions: [{ op: 'is', field: 'payee', value: 'p1' }],
+        }),
+      ).rejects.toThrow(/date condition is required/);
+    });
+
+    it('updateSchedule updates a schedule', async () => {
+      const id = await createSchedule({
+        conditions: [
+          { op: 'is', field: 'payee', value: 'foo' },
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+          },
+        ],
+      });
+
+      let res = await aqlQuery(
+        q('schedules')
+          .filter({ id })
+          .select(['next_date', 'posts_transaction']),
+      );
+      let row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-30');
+      expect(row.posts_transaction).toBe(false);
+
+      MockDate.set(new Date(2021, 4, 17));
+
+      await updateSchedule({
+        schedule: { id, posts_transaction: true },
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 18 },
+                { type: 'day', value: 29 },
+              ],
+            },
+          },
+        ],
+      });
+
+      res = await aqlQuery(
+        q('schedules')
+          .filter({ id })
+          .select(['next_date', 'posts_transaction']),
+      );
+      row = res.data[0];
+
+      // Updating the date condition updates `next_date`
+      expect(row.next_date).toBe('2021-05-18');
+      expect(row.posts_transaction).toBe(true);
+    });
+
+    it('updateSchedule does not update `next_date` when unrelated conditions change', async () => {
+      const id = await createSchedule({
+        conditions: [
+          { op: 'is', field: 'payee', value: 'foo' },
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+          },
+        ],
+      });
+
+      MockDate.set(new Date(2021, 4, 17));
+
+      await updateSchedule({
+        schedule: { id },
+        conditions: [{ op: 'is', field: 'payee', value: 'bar' }],
+      });
+
+      const {
+        data: [row],
+      } = await aqlQuery(q('schedules').filter({ id }).select(['next_date']));
+
+      expect(row.next_date).toBe('2020-12-30');
+    });
+
+    it('updateSchedule ignores the condition `type` field when date value is unchanged', async () => {
+      const id = await createSchedule({
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+          },
+        ],
+      });
+
+      MockDate.set(new Date(2021, 4, 17));
+
+      await updateSchedule({
+        schedule: { id },
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            type: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+          },
+        ],
+      });
+
+      const {
+        data: [row],
+      } = await aqlQuery(q('schedules').filter({ id }).select(['next_date']));
+
+      expect(row.next_date).toBe('2020-12-30');
+    });
+
+    it('deleteSchedule deletes a schedule', async () => {
+      const id = await createSchedule({
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+          },
+        ],
+      });
+
+      const { data: schedules } = await aqlQuery(q('schedules').select('*'));
+      expect(schedules.length).toBe(1);
+
+      await deleteSchedule({ id });
+      const { data: schedules2 } = await aqlQuery(q('schedules').select('*'));
+      expect(schedules2.length).toBe(0);
+    });
+
+    it('setNextDate sets `next_date`', async () => {
+      const id = await createSchedule({
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 15 },
+                { type: 'day', value: 30 },
+              ],
+            },
+          },
+        ],
+      });
+
+      const { data: ruleId } = await aqlQuery(
+        q('schedules').filter({ id }).calculate('rule'),
+      );
+
+      // Manually update the rule
+      await updateRule({
+        id: ruleId,
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-20',
+              frequency: 'monthly',
+              patterns: [
+                { type: 'day', value: 18 },
+                { type: 'day', value: 28 },
+              ],
+            },
+          },
+        ],
+      });
+
+      let res = await aqlQuery(
+        q('schedules').filter({ id }).select(['next_date']),
+      );
+      let row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-30');
+
+      await setNextDate({ id });
+
+      res = await aqlQuery(q('schedules').filter({ id }).select(['next_date']));
+      row = res.data[0];
+
+      expect(row.next_date).toBe('2021-05-18');
+    });
+
+    it('skipNextDate skips `next_date`', async () => {
+      /* Dec 2020 calendar for reference:
+        | Su | Mo | Tu | We | Th | Fr | Sa |
+        |    |    | 01 | 02 | 03 | 04 | 05 |
+        | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
+        | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
+        | 20 | 21 | 22 | 23 | 24 | 25 | 26 |
+        | 27 | 28 | 29 | 30 | 31 |
+        */
+      const id = await createSchedule({
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-05',
+              frequency: 'weekly',
+              patterns: [],
+            },
+          },
+        ],
+      });
+
+      let res = await aqlQuery(
+        q('schedules').filter({ id }).select(['next_date']),
+      );
+      let row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-05');
+
+      await skipNextDate({ id });
+
+      res = await aqlQuery(q('schedules').filter({ id }).select(['next_date']));
+      row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-12');
+    });
+
+    it('skipNextDate skips `next_date` moving `after` weekend', async () => {
+      /* Dec 2020 calendar for reference:
+        | Su | Mo | Tu | We | Th | Fr | Sa |
+        |    |    | 01 | 02 | 03 | 04 | 05 |
+        | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
+        | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
+        | 20 | 21 | 22 | 23 | 24 | 25 | 26 |
+        | 27 | 28 | 29 | 30 | 31 |
+        */
+      const id = await createSchedule({
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-05',
+              frequency: 'weekly',
+              patterns: [],
+              skipWeekend: true,
+              weekendSolveMode: 'after',
+            },
+          },
+        ],
+      });
+
+      let res = await aqlQuery(
+        q('schedules').filter({ id }).select(['next_date']),
+      );
+      let row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-07');
+
+      await skipNextDate({ id });
+
+      res = await aqlQuery(q('schedules').filter({ id }).select(['next_date']));
+      row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-14');
+    });
+
+    it('skipNextDate skips `next_date` moving `before` weekend', async () => {
+      /* Dec 2020 calendar for reference:
+        | Su | Mo | Tu | We | Th | Fr | Sa |
+        |    |    | 01 | 02 | 03 | 04 | 05 |
+        | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
+        | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
+        | 20 | 21 | 22 | 23 | 24 | 25 | 26 |
+        | 27 | 28 | 29 | 30 | 31 |
+        */
+      const id = await createSchedule({
+        conditions: [
+          {
+            op: 'is',
+            field: 'date',
+            value: {
+              start: '2020-12-05',
+              frequency: 'weekly',
+              patterns: [],
+              skipWeekend: true,
+              weekendSolveMode: 'before',
+            },
+          },
+        ],
+      });
+
+      let res = await aqlQuery(
+        q('schedules').filter({ id }).select(['next_date']),
+      );
+      let row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-04');
+
+      await skipNextDate({ id });
+
+      res = await aqlQuery(q('schedules').filter({ id }).select(['next_date']));
+      row = res.data[0];
+
+      expect(row.next_date).toBe('2020-12-11');
+    });
+  });
+});