forked from profectus/Profectus
111 lines
3.8 KiB
TypeScript
111 lines
3.8 KiB
TypeScript
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);
|
|
});
|
|
});
|