Merge pull request #1979 from obsidian-tasks-group/more-expressive-tests

test: More custom matchers, for easier Task testing

Author: claremacrae

tests/CustomMatchers/CustomMatchersForTaskBuilder.ts

@@ -0,0 +1,36 @@
+import type { TaskBuilder } from '../TestingTools/TaskBuilder';
+
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeIdenticalTo(builder2: TaskBuilder): R;
+        }
+
+        interface Expect {
+            toBeIdenticalTo(builder2: TaskBuilder): any;
+        }
+
+        interface InverseAsymmetricMatchers {
+            toBeIdenticalTo(builder2: TaskBuilder): any;
+        }
+    }
+}
+
+export function toBeIdenticalTo(builder1: TaskBuilder, builder2: TaskBuilder) {
+    const task1 = builder1.build();
+    const task2 = builder2.build();
+    const pass = task1.identicalTo(task2);
+
+    if (pass) {
+        return {
+            message: () => 'Tasks treated as identical, but should be different',
+            pass: true,
+        };
+    }
+    return {
+        message: () => {
+            return 'Tasks should be identical, but are treated as different';
+        },
+        pass: false,
+    };
+}

tests/CustomMatchers/CustomMatchersForTasks.ts

@@ -0,0 +1,48 @@
+import { diff } from 'jest-diff';
+import { fromLine } from '../TestHelpers';
+
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toToggleTo(expectedLines: string[]): R;
+            toToggleWithRecurrenceInUsersOrderTo(expectedLines: string[]): R;
+        }
+
+        interface Expect {
+            toToggleTo(expectedLines: string[]): any;
+            toToggleWithRecurrenceInUsersOrderTo(expectedLines: string[]): any;
+        }
+
+        interface InverseAsymmetricMatchers {
+            toToggleTo(expectedLines: string[]): any;
+            toToggleWithRecurrenceInUsersOrderTo(expectedLines: string[]): any;
+        }
+    }
+}
+
+export function toToggleTo(line: string, expectedLines: string[]) {
+    const task = fromLine({ line: line });
+    const receivedLines = task.toggle().map((t) => t.toFileLineString());
+    return toMatchLines(receivedLines, expectedLines);
+}
+
+export function toToggleWithRecurrenceInUsersOrderTo(line: string, expectedLines: string[]) {
+    const task = fromLine({ line: line });
+    const receivedLines = task.toggleWithRecurrenceInUsersOrder().map((t) => t.toFileLineString());
+    return toMatchLines(receivedLines, expectedLines);
+}
+
+function toMatchLines(receivedLines: string[], expectedLines: string[]) {
+    const matches = receivedLines.join('\n') === expectedLines.join('\n');
+    if (!matches) {
+        return {
+            message: () => 'unexpected incorrect new task lines:\n' + diff(expectedLines, receivedLines),
+            pass: false,
+        };
+    }
+
+    return {
+        message: () => `new task lines" should not be: "${receivedLines}"`,
+        pass: true,
+    };
+}

tests/CustomMatchers/jest.custom_matchers.setup.ts

@@ -10,11 +10,6 @@ import {
     toMatchTaskWithPath,
     toMatchTaskWithStatus,
 } from './CustomMatchersForFilters';
-
-import { toSupportGroupingWithProperty } from './CustomMatchersForGrouping';
-
-import { toMatchTaskDetails } from './CustomMatchersForTaskSerializer';
-
 expect.extend({
     toBeValid,
     toHaveExplanation,
@@ -23,6 +18,37 @@ expect.extend({
     toMatchTaskWithHeading,
     toMatchTaskWithPath,
     toMatchTaskWithStatus,
-    toMatchTaskDetails,
+});
+
+// ---------------------------------------------------------------------
+// CustomMatchersForGrouping
+// ---------------------------------------------------------------------
+import { toSupportGroupingWithProperty } from './CustomMatchersForGrouping';
+expect.extend({
     toSupportGroupingWithProperty,
 });
+
+// ---------------------------------------------------------------------
+// CustomMatchersForTaskBuilder
+// ---------------------------------------------------------------------
+import { toBeIdenticalTo } from './CustomMatchersForTaskBuilder';
+expect.extend({
+    toBeIdenticalTo,
+});
+
+// ---------------------------------------------------------------------
+// CustomMatchersForTasks
+// ---------------------------------------------------------------------
+import { toToggleTo, toToggleWithRecurrenceInUsersOrderTo } from './CustomMatchersForTasks';
+expect.extend({
+    toToggleTo,
+    toToggleWithRecurrenceInUsersOrderTo,
+});
+
+// ---------------------------------------------------------------------
+// CustomMatchersForTaskBuilder
+// ---------------------------------------------------------------------
+import { toMatchTaskDetails } from './CustomMatchersForTaskSerializer';
+expect.extend({
+    toMatchTaskDetails,
+});

tests/Task.test.ts

@@ -1018,107 +1018,63 @@ describe('toggle done', () => {
     });
 });
 
-describe('set correct created date on reccurence task', () => {
-    it('does not set created date with disabled setting', () => {
-        // Arrange
-        const line = '- [ ] this is a task 📅 2021-09-12 🔁 every day';
-        updateSettings({ setCreatedDate: false });
-
-        // Act
-        const task = fromLine({
-            line,
-        });
-
-        // Assert
-        expect(task).not.toBeNull();
-        expect(task!.createdDate).toBeNull();
-
-        const tasks = task!.toggle();
-        expect(tasks.length).toEqual(2);
-        const nextTask: Task = tasks[0];
-        expect(nextTask.createdDate).toBeNull();
+describe('created dates on recurring task', () => {
+    beforeEach(() => {
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date('2023-03-08'));
+    });
 
-        // cleanup
+    afterEach(() => {
+        jest.useRealTimers();
         resetSettings();
     });
 
-    it('does not set created date with disabled setting when repeated has created date', () => {
+    it('should not set created date with disabled setting', () => {
         // Arrange
-        const line = '- [ ] this is a task ➕ 2021-09-11 📅 2021-09-12 🔁 every day';
+        const line = '- [ ] this is a task 🔁 every day 📅 2021-09-12';
         updateSettings({ setCreatedDate: false });
 
         // Act
-        const task = fromLine({
-            line,
-        });
-
-        // Assert
-        expect(task).not.toBeNull();
-        expect(task!.createdDate).not.toBeNull();
-        expect(task!.createdDate!.isSame(moment('2021-09-11', 'YYYY-MM-DD'))).toStrictEqual(true);
+        expect(line).toToggleTo([
+            '- [ ] this is a task 🔁 every day 📅 2021-09-13',
+            '- [x] this is a task 🔁 every day 📅 2021-09-12 ✅ 2023-03-08',
+        ]);
+    });
 
-        const tasks = task!.toggle();
-        expect(tasks.length).toEqual(2);
-        const nextTask: Task = tasks[0];
-        expect(nextTask.createdDate).toBeNull();
+    it('should not set created date if setting disabled, even if original has created date', () => {
+        // Arrange
+        const line = '- [ ] this is a task 🔁 every day ➕ 2021-09-11 📅 2021-09-12';
+        updateSettings({ setCreatedDate: false });
 
-        // cleanup
-        resetSettings();
+        // Act
+        expect(line).toToggleTo([
+            '- [ ] this is a task 🔁 every day 📅 2021-09-13',
+            '- [x] this is a task 🔁 every day ➕ 2021-09-11 📅 2021-09-12 ✅ 2023-03-08',
+        ]);
     });
 
-    it('set created date with enabled setting', () => {
+    it('should set created date if setting enabled', () => {
         // Arrange
-        const today = '2023-03-08';
-        const todaySpy = jest.spyOn(Date, 'now').mockReturnValue(moment(today).valueOf());
-        const line = '- [ ] this is a task 📅 2021-09-12 🔁 every day';
+        const line = '- [ ] this is a task 🔁 every day 📅 2021-09-12';
         updateSettings({ setCreatedDate: true });
 
         // Act
-        const task = fromLine({
-            line,
-        });
-
-        // Assert
-        expect(task).not.toBeNull();
-        expect(task!.createdDate).toBeNull();
-
-        const tasks = task!.toggle();
-        expect(tasks.length).toEqual(2);
-        const nextTask: Task = tasks[0];
-        expect(nextTask.createdDate).not.toBeNull();
-        expect(nextTask!.createdDate!.isSame(moment(today, 'YYYY-MM-DD'))).toStrictEqual(true);
-
-        // cleanup
-        resetSettings();
-        todaySpy.mockClear();
+        expect(line).toToggleTo([
+            '- [ ] this is a task 🔁 every day ➕ 2023-03-08 📅 2021-09-13',
+            '- [x] this is a task 🔁 every day 📅 2021-09-12 ✅ 2023-03-08',
+        ]);
     });
 
-    it('set created date with enabled setting when repeated has created date', () => {
+    it('should set created date if setting enabled, when original has created date', () => {
         // Arrange
-        const today = '2023-03-08';
-        const todaySpy = jest.spyOn(Date, 'now').mockReturnValue(moment(today).valueOf());
-        const line = '- [ ] this is a task ➕ 2021-09-11 📅 2021-09-12 🔁 every day';
+        const line = '- [ ] this is a task 🔁 every day ➕ 2021-09-11 📅 2021-09-12';
         updateSettings({ setCreatedDate: true });
 
         // Act
-        const task = fromLine({
-            line,
-        });
-
-        // Assert
-        expect(task).not.toBeNull();
-        expect(task!.createdDate).not.toBeNull();
-        expect(task!.createdDate!.isSame(moment('2021-09-11', 'YYYY-MM-DD'))).toStrictEqual(true);
-
-        const tasks = task!.toggle();
-        expect(tasks.length).toEqual(2);
-        const nextTask: Task = tasks[0];
-        expect(nextTask.createdDate).not.toBeNull();
-        expect(nextTask!.createdDate!.isSame(moment(today, 'YYYY-MM-DD'))).toStrictEqual(true);
-
-        // cleanup
-        resetSettings();
-        todaySpy.mockClear();
+        expect(line).toToggleTo([
+            '- [ ] this is a task 🔁 every day ➕ 2023-03-08 📅 2021-09-13',
+            '- [x] this is a task 🔁 every day ➕ 2021-09-11 📅 2021-09-12 ✅ 2023-03-08',
+        ]);
     });
 });
 
@@ -1134,19 +1090,9 @@ describe('order of recurring tasks', () => {
         resetSettings();
     });
 
-    function togglingInUsersOrderShouldGive(line: string, expectedLines: string[]) {
-        // Arrange
-        const task = fromLine({ line: line });
-
-        // Act
-        const lines = task.toggleWithRecurrenceInUsersOrder().map((t) => t.toFileLineString());
-
-        // Assert
-        expect(lines).toStrictEqual(expectedLines);
-    }
-
     it('should put new task before old, by default', () => {
-        togglingInUsersOrderShouldGive('- [ ] this is a recurring task 🔁 every day', [
+        const line = '- [ ] this is a recurring task 🔁 every day';
+        expect(line).toToggleWithRecurrenceInUsersOrderTo([
             '- [ ] this is a recurring task 🔁 every day',
             '- [x] this is a recurring task 🔁 every day ✅ 2023-05-16',
         ]);
@@ -1155,7 +1101,8 @@ describe('order of recurring tasks', () => {
     it('should honour new-task-before-old setting', () => {
         updateSettings({ recurrenceOnNextLine: false });
 
-        togglingInUsersOrderShouldGive('- [ ] this is a recurring task 🔁 every day', [
+        const line = '- [ ] this is a recurring task 🔁 every day';
+        expect(line).toToggleWithRecurrenceInUsersOrderTo([
             '- [ ] this is a recurring task 🔁 every day',
             '- [x] this is a recurring task 🔁 every day ✅ 2023-05-16',
         ]);
@@ -1164,52 +1111,14 @@ describe('order of recurring tasks', () => {
     it('should honour old-task-before-new setting', () => {
         updateSettings({ recurrenceOnNextLine: true });
 
-        togglingInUsersOrderShouldGive('- [ ] this is a recurring task 🔁 every day', [
+        const line = '- [ ] this is a recurring task 🔁 every day';
+        expect(line).toToggleWithRecurrenceInUsersOrderTo([
             '- [x] this is a recurring task 🔁 every day ✅ 2023-05-16',
             '- [ ] this is a recurring task 🔁 every day',
         ]);
     });
 });
 
-declare global {
-    namespace jest {
-        interface Matchers<R> {
-            toBeIdenticalTo(builder2: TaskBuilder): R;
-        }
-
-        interface Expect {
-            toBeIdenticalTo(builder2: TaskBuilder): any;
-        }
-
-        interface InverseAsymmetricMatchers {
-            toBeIdenticalTo(builder2: TaskBuilder): any;
-        }
-    }
-}
-
-export function toBeIdenticalTo(builder1: TaskBuilder, builder2: TaskBuilder) {
-    const task1 = builder1.build();
-    const task2 = builder2.build();
-    const pass = task1.identicalTo(task2);
-
-    if (pass) {
-        return {
-            message: () => 'Tasks treated as identical, but should be different',
-            pass: true,
-        };
-    }
-    return {
-        message: () => {
-            return 'Tasks should be identical, but are treated as different';
-        },
-        pass: false,
-    };
-}
-
-expect.extend({
-    toBeIdenticalTo,
-});
-
 describe('identicalTo', () => {
     it('should check status', () => {
         const lhs = new TaskBuilder().status(Status.TODO);