test: add tests for toggling node programmatically feature

Author: Lodin

__tests__/FixedSizeTree.spec.tsx

@@ -419,19 +419,80 @@ describe('FixedSizeTree', () => {
         });
       });
 
-      it('provides a toggle function that changes openness state of the specific node', async () => {
-        const foo1 = component.state('records')['foo-1']!;
+      it('opens and closes nodes as specified in opennessState', async () => {
+        await treeInstance.recomputeTree({
+          opennessState: {
+            'foo-2': false,
+          },
+        });
+
+        component.update(); // Update the wrapper to get the latest changes
+
+        let {
+          order,
+          records: {'foo-1': foo1, 'foo-2': foo2, 'foo-3': foo3},
+        }: FixedSizeTreeState<FixedSizeNodeData> = component
+          .find(FixedSizeList)
+          .prop('itemData');
+
+        expect(order).toEqual(['foo-1', 'foo-2', 'foo-3']);
+        expect(foo1!.isOpen).toBeTruthy();
+        expect(foo2!.isOpen).not.toBeTruthy();
+        expect(foo3!.isOpen).toBeTruthy();
+
+        await treeInstance.recomputeTree({
+          opennessState: {
+            'foo-2': true,
+            'foo-3': false,
+          },
+        });
+
+        component.update(); // Update the wrapper to get the latest changes
 
-        treeWalkerSpy.mockClear();
+        ({
+          order,
+          records: {'foo-1': foo1, 'foo-2': foo2, 'foo-3': foo3},
+        } = component.find(FixedSizeList).prop('itemData'));
 
-        // Imitate the behavior of Node component where toggle is sent without
-        // context
-        const {toggle} = foo1;
-        await toggle();
+        expect(order).toEqual(['foo-1', 'foo-2', 'foo-3']);
+        expect(foo1!.isOpen).toBeTruthy();
+        expect(foo2!.isOpen).toBeTruthy();
+        expect(foo3!.isOpen).not.toBeTruthy();
+      });
+
+      it('opennessState is overridden by useDefaultOpenness', async () => {
+        await treeInstance.recomputeTree({
+          opennessState: {
+            'foo-2': false,
+          },
+          useDefaultOpenness: true,
+        });
+        component.update(); // Update the wrapper to get the latest changes
 
-        expect(treeWalkerSpy).toHaveBeenCalledWith(false);
-        expect(foo1.isOpen).toBeFalsy();
+        const {
+          records: {'foo-1': foo1, 'foo-2': foo2, 'foo-3': foo3},
+        }: FixedSizeTreeState<FixedSizeNodeData> = component
+          .find(FixedSizeList)
+          .prop('itemData');
+
+        expect(foo1!.isOpen).toBeTruthy();
+        expect(foo2!.isOpen).toBeTruthy();
+        expect(foo3!.isOpen).toBeTruthy();
       });
     });
+
+    it('provides a toggle function that changes openness state of the specific node', async () => {
+      const foo1 = component.state('records')['foo-1']!;
+
+      treeWalkerSpy.mockClear();
+
+      // Imitate the behavior of Node component where toggle is sent without
+      // context
+      const {toggle} = foo1;
+      await toggle();
+
+      expect(treeWalkerSpy).toHaveBeenCalledWith(false);
+      expect(foo1.isOpen).toBeFalsy();
+    });
   });
 });

__tests__/VariableSizeTree.spec.tsx

@@ -607,23 +607,84 @@ describe('VariableSizeTree', () => {
         );
       });
 
-      it('provides a resize function that changes height of the specific node', () => {
-        const listInstance: VariableSizeList = component
+      it('opens and closes nodes as specified in opennessState', async () => {
+        await treeInstance.recomputeTree({
+          opennessState: {
+            'foo-2': false,
+          },
+        });
+
+        component.update(); // Update the wrapper to get the latest changes
+
+        let {
+          order,
+          records: {'foo-1': foo1, 'foo-2': foo2, 'foo-3': foo3},
+        }: VariableSizeTreeState<VariableSizeNodeData> = component
           .find(VariableSizeList)
-          .instance() as VariableSizeList;
+          .prop('itemData');
 
-        const resetAfterIndexSpy = jest.spyOn(listInstance, 'resetAfterIndex');
-        const order = component.state('order')!;
-        const foo3 = component.state('records')['foo-3']!;
+        expect(order).toEqual(['foo-1', 'foo-2', 'foo-3']);
+        expect(foo1!.isOpen).toBeTruthy();
+        expect(foo2!.isOpen).not.toBeTruthy();
+        expect(foo3!.isOpen).toBeTruthy();
 
-        foo3.resize(100, true);
+        await treeInstance.recomputeTree({
+          opennessState: {
+            'foo-2': true,
+            'foo-3': false,
+          },
+        });
 
-        expect(resetAfterIndexSpy).toHaveBeenCalledWith(
-          order.indexOf('foo-3'),
-          true,
-        );
-        expect(foo3.height).toBe(100);
+        component.update(); // Update the wrapper to get the latest changes
+
+        ({
+          order,
+          records: {'foo-1': foo1, 'foo-2': foo2, 'foo-3': foo3},
+        } = component.find(VariableSizeList).prop('itemData'));
+
+        expect(order).toEqual(['foo-1', 'foo-2', 'foo-3']);
+        expect(foo1!.isOpen).toBeTruthy();
+        expect(foo2!.isOpen).toBeTruthy();
+        expect(foo3!.isOpen).not.toBeTruthy();
       });
+
+      it('opennessState is overridden by useDefaultOpenness', async () => {
+        await treeInstance.recomputeTree({
+          opennessState: {
+            'foo-2': false,
+          },
+          useDefaultOpenness: true,
+        });
+        component.update(); // Update the wrapper to get the latest changes
+
+        const {
+          records: {'foo-1': foo1, 'foo-2': foo2, 'foo-3': foo3},
+        }: VariableSizeTreeState<VariableSizeNodeData> = component
+          .find(VariableSizeList)
+          .prop('itemData');
+
+        expect(foo1!.isOpen).toBeTruthy();
+        expect(foo2!.isOpen).toBeTruthy();
+        expect(foo3!.isOpen).toBeTruthy();
+      });
+    });
+
+    it('provides a resize function that changes height of the specific node', () => {
+      const listInstance: VariableSizeList = component
+        .find(VariableSizeList)
+        .instance() as VariableSizeList;
+
+      const resetAfterIndexSpy = jest.spyOn(listInstance, 'resetAfterIndex');
+      const order = component.state('order')!;
+      const foo3 = component.state('records')['foo-3']!;
+
+      foo3.resize(100, true);
+
+      expect(resetAfterIndexSpy).toHaveBeenCalledWith(
+        order.indexOf('foo-3'),
+        true,
+      );
+      expect(foo3.height).toBe(100);
     });
   });
 });

src/Tree.tsx

@@ -54,23 +54,6 @@ export type TreeWalker<T> = (
   refresh: boolean,
 ) => Generator<T | string | symbol, void, boolean>;
 
-export type OverridableMethods = Readonly<{
-  constructRecord: (
-    data: NodeData,
-    state: TreeState<any, any, any, any>,
-  ) => NodeRecord<NodeData>;
-  shouldUpdateRecords: (options: UpdateOptions) => boolean;
-  updateRecord: (
-    record: NodeRecord<NodeData>,
-    recordId: string,
-    options: UpdateOptions,
-  ) => void;
-  updateRecordDuringTreeWalk: (
-    record: NodeRecord<NodeData>,
-    options: UpdateOptions,
-  ) => void;
-}>;
-
 export type TreeProps<
   TNodeComponentProps extends NodeComponentProps<TData>,
   TData extends NodeData