test: Move custom Jest matchers to separate file (#1019)

* test: Move toMatchTaskWithDescription() to separate file

To allow for re-use.

* test: Add comment saying how to use extracted code

* test: Move toMatchTaskWithPath() & toBeValid() to separate file

* test: Combine 2 'namespace jest' blocks in to 1

* test: Make function order in file consistent

The functions are now implemented in the same order that they
are used in the 'namespace jest' block at the top of the file.

* test: Clarify a comment

Now that custom matchers are available.

* test: Move custom matchers to tests/CustomMatchers/

Author: claremacrae

tests/CustomMatchers/CustomMatchersForFilters.ts

@@ -0,0 +1,101 @@
+import type { FilterOrErrorMessage } from '../../src/Query/Filter/Filter';
+import { fromLine } from '../TestHelpers';
+import { TaskBuilder } from '../TestingTools/TaskBuilder';
+
+/* Example usage (shown for toMatchTaskWithDescription(), but other matchers are available.
+
+import { toMatchTaskWithDescription } from '<relative-path>/CustomMatchersForFilters';
+
+expect.extend({
+    toMatchTaskWithDescription,
+});
+
+ */
+
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeValid(): R;
+            toMatchTaskWithDescription(description: string): R;
+            toMatchTaskWithPath(path: string): R;
+        }
+
+        interface Expect {
+            toBeValid(): any;
+            toMatchTaskWithDescription(description: string): any;
+            toMatchTaskWithPath(path: string): any;
+        }
+
+        interface InverseAsymmetricMatchers {
+            toBeValid(): any;
+            toMatchTaskWithDescription(description: string): any;
+            toMatchTaskWithPath(path: string): any;
+        }
+    }
+}
+
+export function toBeValid(filter: FilterOrErrorMessage) {
+    if (filter.filter === undefined) {
+        return {
+            message: () =>
+                'unexpected null filter: check your instruction matches your filter class',
+            pass: false,
+        };
+    }
+
+    if (filter.error !== undefined) {
+        return {
+            message: () =>
+                'unexpected error message in filter: check your instruction matches your filter class',
+            pass: false,
+        };
+    }
+
+    return {
+        message: () => 'filter is unexpectedly valid',
+        pass: true,
+    };
+}
+
+export function toMatchTaskWithDescription(
+    filter: FilterOrErrorMessage,
+    description: string,
+) {
+    const task = fromLine({
+        line: description,
+    });
+
+    const matches = filter.filter!(task);
+    if (!matches) {
+        return {
+            message: () => `unexpected failure to match task: ${description}`,
+            pass: false,
+        };
+    }
+
+    return {
+        message: () => `filter should not have matched task: ${description}`,
+        pass: true,
+    };
+}
+
+export function toMatchTaskWithPath(
+    filter: FilterOrErrorMessage,
+    path: string,
+) {
+    const builder = new TaskBuilder();
+    const task = builder.path(path).build();
+
+    const matches = filter.filter!(task);
+    if (!matches) {
+        return {
+            message: () => `unexpected failure to match task: ${path}`,
+            pass: false,
+        };
+    }
+
+    return {
+        message: () => `filter should not have matched task: ${path}`,
+        pass: true,
+    };
+}

tests/Query/Filter/DescriptionField.test.ts

@@ -3,6 +3,7 @@ import { getSettings, updateSettings } from '../../../src/config/Settings';
 import { testTaskFilter } from '../../TestingTools/FilterTestHelpers';
 import { fromLine } from '../../TestHelpers';
 import type { FilterOrErrorMessage } from '../../../src/Query/Filter/Filter';
+import { toMatchTaskWithDescription } from '../../CustomMatchers/CustomMatchersForFilters';
 
 function testDescriptionFilter(
     filter: FilterOrErrorMessage,
@@ -15,44 +16,6 @@ function testDescriptionFilter(
     testTaskFilter(filter, task, expected);
 }
 
-declare global {
-    namespace jest {
-        interface Matchers<R> {
-            toMatchTaskWithDescription(description: string): R;
-        }
-
-        interface Expect {
-            toMatchTaskWithDescription(description: string): any;
-        }
-
-        interface InverseAsymmetricMatchers {
-            toMatchTaskWithDescription(description: string): any;
-        }
-    }
-}
-
-export function toMatchTaskWithDescription(
-    filter: FilterOrErrorMessage,
-    description: string,
-) {
-    const task = fromLine({
-        line: description,
-    });
-
-    const matches = filter.filter!(task);
-    if (!matches) {
-        return {
-            message: () => `unexpected failure to match task: ${description}`,
-            pass: false,
-        };
-    }
-
-    return {
-        message: () => `filter should not have matched task: ${description}`,
-        pass: true,
-    };
-}
-
 expect.extend({
     toMatchTaskWithDescription,
 });

tests/Query/Filter/PathField.test.ts

@@ -2,6 +2,10 @@ import { PathField } from '../../../src/Query/Filter/PathField';
 import type { FilterOrErrorMessage } from '../../../src/Query/Filter/Filter';
 import { TaskBuilder } from '../../TestingTools/TaskBuilder';
 import { testFilter } from '../../TestingTools/FilterTestHelpers';
+import {
+    toBeValid,
+    toMatchTaskWithPath,
+} from '../../CustomMatchers/CustomMatchersForFilters';
 
 function testTaskFilterForTaskWithPath(
     filter: FilterOrErrorMessage,
@@ -12,69 +16,6 @@ function testTaskFilterForTaskWithPath(
     testFilter(filter, builder.path(path), expected);
 }
 
-declare global {
-    namespace jest {
-        interface Matchers<R> {
-            toMatchTaskWithPath(path: string): R;
-            toBeValid(): R;
-        }
-
-        interface Expect {
-            toMatchTaskWithPath(path: string): any;
-            toBeValid(): any;
-        }
-
-        interface InverseAsymmetricMatchers {
-            toMatchTaskWithPath(path: string): any;
-            toBeValid(): any;
-        }
-    }
-}
-
-export function toBeValid(filter: FilterOrErrorMessage) {
-    if (filter.filter === undefined) {
-        return {
-            message: () =>
-                'unexpected null filter: check your instruction matches your filter class',
-            pass: false,
-        };
-    }
-
-    if (filter.error !== undefined) {
-        return {
-            message: () =>
-                'unexpected error message in filter: check your instruction matches your filter class',
-            pass: false,
-        };
-    }
-
-    return {
-        message: () => 'filter is unexpectedly valid',
-        pass: true,
-    };
-}
-
-export function toMatchTaskWithPath(
-    filter: FilterOrErrorMessage,
-    path: string,
-) {
-    const builder = new TaskBuilder();
-    const task = builder.path(path).build();
-
-    const matches = filter.filter!(task);
-    if (!matches) {
-        return {
-            message: () => `unexpected failure to match task: ${path}`,
-            pass: false,
-        };
-    }
-
-    return {
-        message: () => `filter should not have matched task: ${path}`,
-        pass: true,
-    };
-}
-
 expect.extend({
     toMatchTaskWithPath,
 });