From 1f22f506dd978a352a62a50a7a95209da3a30344 Mon Sep 17 00:00:00 2001
From: thepaperpilot <thepaperpilot@gmail.com>
Date: Tue, 13 Feb 2024 08:25:32 -0600
Subject: [PATCH] Add tests for tree reset propagation

---
 src/features/trees/tree.ts  |   2 +-
 tests/features/tree.test.ts | 111 ++++++++++++++++++++++++++++++++++++
 2 files changed, 112 insertions(+), 1 deletion(-)
 create mode 100644 tests/features/tree.test.ts

diff --git a/src/features/trees/tree.ts b/src/features/trees/tree.ts
index 8ec317f..4e43bbf 100644
--- a/src/features/trees/tree.ts
+++ b/src/features/trees/tree.ts
@@ -224,7 +224,7 @@ export interface BaseTree {
     id: string;
     /** The link objects for each of the branches of the tree.  */
     links: Ref<Link[]>;
-    /** Cause a reset on this node and propagate it through the tree according to {@link resetPropagation}. */
+    /** Cause a reset on this node and propagate it through the tree according to {@link TreeOptions.resetPropagation}. */
     reset: (node: GenericTreeNode) => void;
     /** A flag that is true while the reset is still propagating through the tree. */
     isResetting: Ref<boolean>;
diff --git a/tests/features/tree.test.ts b/tests/features/tree.test.ts
new file mode 100644
index 0000000..206988f
--- /dev/null
+++ b/tests/features/tree.test.ts
@@ -0,0 +1,111 @@
+import { beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+import { Ref, ref } from "vue";
+import "../utils";
+import {
+    createTree,
+    createTreeNode,
+    defaultResetPropagation,
+    invertedResetPropagation,
+    branchedResetPropagation
+} from "features/trees/tree";
+import { createReset, GenericReset } from "features/reset";
+
+describe("Reset propagation", () => {
+    let shouldReset: Ref<boolean>, shouldNotReset: Ref<boolean>;
+    let goodReset: GenericReset, badReset: GenericReset;
+    beforeAll(() => {
+        shouldReset = ref(false);
+        shouldNotReset = ref(false);
+        goodReset = createReset(() => ({
+            thingsToReset: [],
+            onReset() {
+                shouldReset.value = true;
+            }
+        }));
+        badReset = createReset(() => ({
+            thingsToReset: [],
+            onReset() {
+                shouldNotReset.value = true;
+            }
+        }));
+    });
+    beforeEach(() => {
+        shouldReset.value = false;
+        shouldNotReset.value = false;
+    });
+    test("No resets", () => {
+        expect(() => {
+            const a = createTreeNode(() => ({}));
+            const b = createTreeNode(() => ({}));
+            const c = createTreeNode(() => ({}));
+            const tree = createTree(() => ({
+                nodes: [[a], [b], [c]]
+            }));
+            tree.reset(a);
+        }).not.toThrowError();
+    });
+
+    test("Do not propagate resets", () => {
+        const a = createTreeNode(() => ({ reset: badReset }));
+        const b = createTreeNode(() => ({ reset: badReset }));
+        const c = createTreeNode(() => ({ reset: badReset }));
+        const tree = createTree(() => ({
+            nodes: [[a], [b], [c]]
+        }));
+        tree.reset(b);
+        expect(shouldNotReset.value).toBe(false);
+    });
+
+    test("Default propagation", () => {
+        const a = createTreeNode(() => ({ reset: goodReset }));
+        const b = createTreeNode(() => ({}));
+        const c = createTreeNode(() => ({ reset: badReset }));
+        const tree = createTree(() => ({
+            nodes: [[a], [b], [c]],
+            resetPropagation: defaultResetPropagation
+        }));
+        tree.reset(b);
+        expect(shouldReset.value).toBe(true);
+        expect(shouldNotReset.value).toBe(false);
+    });
+
+    test("Inverted propagation", () => {
+        const a = createTreeNode(() => ({ reset: badReset }));
+        const b = createTreeNode(() => ({}));
+        const c = createTreeNode(() => ({ reset: goodReset }));
+        const tree = createTree(() => ({
+            nodes: [[a], [b], [c]],
+            resetPropagation: invertedResetPropagation
+        }));
+        tree.reset(b);
+        expect(shouldReset.value).toBe(true);
+        expect(shouldNotReset.value).toBe(false);
+    });
+
+    test("Branched propagation", () => {
+        const a = createTreeNode(() => ({ reset: badReset }));
+        const b = createTreeNode(() => ({}));
+        const c = createTreeNode(() => ({ reset: goodReset }));
+        const tree = createTree(() => ({
+            nodes: [[a, b, c]],
+            resetPropagation: branchedResetPropagation,
+            branches: [{ startNode: b, endNode: c }]
+        }));
+        tree.reset(b);
+        expect(shouldReset.value).toBe(true);
+        expect(shouldNotReset.value).toBe(false);
+    });
+
+    test("Branched propagation not bi-directional", () => {
+        const a = createTreeNode(() => ({ reset: badReset }));
+        const b = createTreeNode(() => ({}));
+        const c = createTreeNode(() => ({ reset: badReset }));
+        const tree = createTree(() => ({
+            nodes: [[a, b, c]],
+            resetPropagation: branchedResetPropagation,
+            branches: [{ startNode: c, endNode: b }]
+        }));
+        tree.reset(b);
+        expect(shouldNotReset.value).toBe(false);
+    });
+});