@zeedhi/common 1.111.1 → 3.0.0

package/tests/unit/components/zd-tree/tree.spec.ts

@@ -0,0 +1,905 @@
+import { IDictionary, Http, Metadata } from '@zeedhi/core';
+import {
+  ITreeNodeModel, Tree, ICursorPosition, ITreeNode,
+} from '../../../../src';
+
+describe('Tree', () => {
+  describe('constructor()', () => {
+    it('should create new tree with default values', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree' });
+      expect(instance.nodes).toEqual([]);
+      expect(instance.itemIconName).toBe('');
+      expect(instance.groupIconName).toBe('');
+      expect(instance.openedIconName).toBe('');
+      expect(instance.closedIconName).toBe('');
+      expect(instance.allowMultiSelect).toBeTruthy();
+      expect(instance.allowDragDrop).toBeTruthy();
+      expect(instance.afterTitleSlot).toBeUndefined();
+      expect(instance.toolbarSlot).toEqual([]);
+      expect(instance.titleSlot).toEqual([]);
+      expect(instance.checkbox).toBeFalsy();
+      expect(instance.checkedField).toBe('checked');
+      expect(instance.disableCheckbox).toBeUndefined();
+      expect(instance.height).toBe('auto');
+      expect(instance.minHeight).toBe('auto');
+      expect(instance.maxHeight).toBe('none');
+      expect(instance.fillHeight).toBeFalsy();
+      expect(instance.width).toBe('100%');
+      expect(instance.minWidth).toBe('auto');
+      expect(instance.maxWidth).toBe('none');
+    });
+
+    it('should create new tree replacing default values', () => {
+      const fn = jest.fn();
+      const instance = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        nodes: [{ title: 'title' }],
+        itemIconName: 'magnify',
+        groupIconName: 'menu',
+        openedIconName: 'expand',
+        closedIconName: 'chevronRight',
+        allowMultiSelect: false,
+        allowDragDrop: false,
+        afterTitleSlot: { name: 'text', component: 'ZdText' },
+        toolbarSlot: [],
+        titleSlot: [{ name: 'text', component: 'ZdText' }],
+        checkbox: true,
+        checkedField: 'field',
+        disableCheckbox: fn,
+        height: '400px',
+        maxHeight: '500px',
+        minHeight: '500px',
+        width: '400px',
+        maxWidth: '500px',
+        minWidth: '500px',
+        fillHeight: true,
+      });
+      expect(instance.nodes).toMatchObject([{ title: 'title' }]);
+      expect(instance.itemIconName).toBe('magnify');
+      expect(instance.groupIconName).toBe('menu');
+      expect(instance.openedIconName).toBe('expand');
+      expect(instance.closedIconName).toBe('chevronRight');
+      expect(instance.allowMultiSelect).toBeFalsy();
+      expect(instance.allowDragDrop).toBeFalsy();
+      expect(instance.afterTitleSlot).toEqual({ name: 'text', component: 'ZdText' });
+      expect(instance.toolbarSlot).toEqual([]);
+      expect(instance.titleSlot).toEqual([{ name: 'text', component: 'ZdText' }]);
+      expect(instance.checkbox).toBeTruthy();
+      expect(instance.checkedField).toBe('field');
+      expect(instance.height).toBe('400px');
+      expect(instance.maxHeight).toBe('500px');
+      expect(instance.minHeight).toBe('500px');
+      expect(instance.width).toBe('400px');
+      expect(instance.maxWidth).toBe('500px');
+      expect(instance.minWidth).toBe('500px');
+      expect(instance.fillHeight).toBeTruthy();
+      expect(instance.disableCheckbox).toEqual(fn);
+    });
+
+    it('should always set the nodes default values', () => {
+      const nodes = [
+        { title: 'Node 1' },
+        {
+          title: 'Node 2',
+          children: [
+            {
+              title: 'Node 2.1',
+              children: [
+                { title: 'Node 2.1.1' },
+              ],
+            },
+            { title: 'Node 2.2' },
+          ],
+        },
+      ];
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes });
+      expect(instance.getNode([0])).toHaveProperty('title');
+      expect(instance.getNode([0])).toHaveProperty('isLeaf');
+      expect(instance.getNode([0])).toHaveProperty('children');
+      expect(instance.getNode([0])).toHaveProperty('isExpanded');
+      expect(instance.getNode([0])).toHaveProperty('isSelected');
+      expect(instance.getNode([0])).toHaveProperty('isDraggable');
+      expect(instance.getNode([0])).toHaveProperty('isSelectable');
+      expect(instance.getNode([0])?.data).toEqual({ checked: false });
+
+      expect(instance.getNode([1, 0, 0])).toHaveProperty('title');
+      expect(instance.getNode([1, 0, 0])).toHaveProperty('isLeaf');
+      expect(instance.getNode([1, 0, 0])).toHaveProperty('children');
+      expect(instance.getNode([1, 0, 0])).toHaveProperty('isExpanded');
+      expect(instance.getNode([1, 0, 0])).toHaveProperty('isSelected');
+      expect(instance.getNode([1, 0, 0])).toHaveProperty('isDraggable');
+      expect(instance.getNode([1, 0, 0])).toHaveProperty('isSelectable');
+      expect(instance.getNode([1, 0, 0])?.data).toEqual({ checked: false });
+    });
+  });
+
+  describe('createNodesFromDatasource', () => {
+    it('should create nodes using memory datasource', () => {
+      const instance = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        parentField: 'parent',
+        titleField: 'label',
+        openLevelOnLoad: true,
+        datasource: {
+          uniqueKey: 'id',
+          data: [
+            { id: '1', label: 'Node 1' },
+            { id: '1.1', label: 'Node 1.1', parent: '1' },
+            { id: '1.1.1', label: 'Node 1.1.1', parent: '1.1' },
+            { id: '1.1.2', label: 'Node 1.1.2', parent: '1.1' },
+            { id: '1.2', label: 'Node 1.2', parent: '1' },
+            { id: '2', label: 'Node 2' },
+            { id: '2.1', label: 'Node 2.1', parent: '2' },
+          ],
+          get: jest.fn(),
+        },
+      });
+
+      expect(instance.nodes.length).toBe(2);
+      expect(instance.nodes[0].children!.length).toBe(2);
+      expect(instance.nodes[0].isExpanded).toBeTruthy();
+      expect(instance.nodes[0].children![0].children!.length).toBe(2);
+      expect(instance.nodes[0].children![0].isExpanded).toBeTruthy();
+      expect(instance.nodes[1].children!.length).toBe(1);
+      expect(instance.nodes[1].children![0].children!.length).toBe(0);
+      expect(instance.nodes[1].children![0].isLeaf).toBeTruthy();
+
+      instance.datasource!.data.push({ id: '3', label: 'Node 3' });
+      instance.createNodesFromDatasource();
+      expect(instance.nodes.length).toBe(3);
+      expect(instance.nodes[2].children!.length).toBe(0);
+    });
+
+    it('should do nothing if datasource not defined', () => {
+      const instance = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        nodes: [{ title: 'title' }],
+      });
+
+      expect(instance.nodes.length).toBe(1);
+      instance.createNodesFromDatasource();
+      expect(instance.nodes.length).toBe(1);
+    });
+
+    it('should create nodes using rest datasource', async () => {
+      const flushPromises = () => new Promise((resolve) => process.nextTick(resolve));
+
+      const spy = jest.spyOn(Http, 'get').mockImplementation(() => Promise.resolve({
+        data: {
+          data: [
+            { id: '1', label: 'Node 1' },
+            { id: '1.1', label: 'Node 1.1', parent: '1' },
+            { id: '1.1.1', label: 'Node 1.1.1', parent: '1.1' },
+            { id: '1.1.2', label: 'Node 1.1.2', parent: '1.1' },
+            { id: '1.2', label: 'Node 1.2', parent: '1' },
+            { id: '2', label: 'Node 2' },
+            { id: '2.1', label: 'Node 2.1', parent: '2' },
+          ],
+          pagination: { page: 1, total: 7, limit: 15 },
+        },
+      }));
+
+      const instance = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        parentField: 'parent',
+        titleField: 'label',
+        openLevelOnLoad: true,
+        datasource: {
+          uniqueKey: 'id',
+          type: 'rest',
+          route: '/zeedhi',
+          lazyLoad: false,
+          data: [],
+          get: jest.fn(),
+        },
+      });
+
+      await instance.onCreated();
+      await flushPromises();
+      expect(instance.nodes.length).toBe(2);
+
+      spy.mockClear();
+    });
+  });
+
+  describe('insertNode()', () => {
+    it('should insert a node in the empty tree', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree' });
+      instance.insertNode({ title: 'title' });
+      expect(instance.nodes).toMatchObject([{ title: 'title' }]);
+    });
+
+    it('should insert a node in the tree', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes: [{ title: 'title', isSelected: true }] });
+      const treeObject = {
+        getSelected: () => [instance.nodes[0]],
+        insert: (cursorPosition: ICursorPosition<IDictionary>, newNode: ITreeNodeModel<IDictionary>) => {
+          cursorPosition.node.children = [newNode];
+        },
+        updateNode: () => {
+          instance.nodes[0] = {
+            title: 'title', isSelected: true, isLeaf: false, children: [{ title: 'title1' }],
+          };
+        },
+      };
+      instance.setTree(treeObject);
+      instance.insertNode({ title: 'title1' });
+      expect(instance.nodes).toMatchObject([{
+        title: 'title', isSelected: true, isLeaf: false, children: [{ title: 'title1' }],
+      }]);
+    });
+  });
+
+  describe('importNodes()', () => {
+    it('should import a nodes without selected node ', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes: [{ title: 'title' }] });
+      instance.importNodes([{ title: 'title1' }]);
+      expect(instance.nodes).toMatchObject([{ title: 'title' }, { title: 'title1' }]);
+    });
+
+    it('should import a node with selected node', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes: [{ title: 'title', isSelected: true }] });
+      const treeObject = {
+        getSelected: () => [instance.nodes[0]],
+        insert: (cursorPosition: ICursorPosition<IDictionary>, newNode: ITreeNodeModel<IDictionary>) => {
+          cursorPosition.node.children = [newNode];
+        },
+        updateNode: () => { instance.nodes[0] = { title: 'title', isSelected: true, isLeaf: false }; },
+      };
+      instance.setTree(treeObject);
+      instance.importNodes([{ title: 'title1' }]);
+      expect(instance.nodes).toMatchObject([{
+        title: 'title', isSelected: true, isLeaf: false, children: [{ title: 'title1' }],
+      }]);
+    });
+  });
+
+  describe('removeSelected()', () => {
+    it('should remove node if selected', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes: [{ title: 'title', isSelected: true }] });
+      const treeObject = {
+        getSelected: () => [{ ...instance.nodes[0], path: [0] }],
+        remove: (path: number[][]) => { if (path[0][0] === 0) instance.nodes = []; },
+      };
+      instance.setTree(treeObject);
+      instance.removeSelected();
+      expect(instance.nodes).toEqual([]);
+    });
+
+    it('should remove child node if selected and update parent isLeaf property', () => {
+      const child = { title: 'node 1.1', isSelected: true };
+      const instance = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        nodes: [{ title: 'node 1', children: [child] }],
+      });
+      const treeObject = {
+        getSelected: () => [{ ...child, path: [0, 0] }],
+        remove: () => { instance.nodes[0].children = []; },
+        getNode: () => ({ title: 'node 1', path: [0], children: [child] }),
+        updateNode: () => { instance.nodes[0].isLeaf = true; },
+      };
+      instance.setTree(treeObject);
+      instance.removeSelected();
+      expect(instance.nodes).toMatchObject([{ title: 'node 1', isLeaf: true, children: [] }]);
+    });
+
+    it('should not remove node if not selected', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes: [{ title: 'title' }] });
+      const treeObject = {
+        getSelected: () => [],
+        remove: (path: number[][]) => { if (path[0][0] === 0) instance.nodes = []; },
+      };
+      instance.setTree(treeObject);
+      instance.removeSelected();
+      expect(instance.nodes).toMatchObject([{ title: 'title' }]);
+    });
+  });
+
+  describe('clearSelection()', () => {
+    it('should clear selected nodes', () => {
+      const instance = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        nodes: [
+          {
+            title: 'title',
+            isSelected: true,
+            children: [
+              {
+                title: 'title2',
+                isSelected: true,
+              },
+            ],
+          },
+        ],
+      });
+      const treeObject = {
+        getSelected: () => [{ ...instance.nodes[0], path: [0] }],
+        remove: (path: number[][]) => { if (path[0][0] === 0) instance.nodes = []; },
+      };
+      instance.setTree(treeObject);
+      expect(instance.nodes).toMatchObject([
+        {
+          title: 'title',
+          isSelected: true,
+          children: [
+            {
+              title: 'title2',
+              isSelected: true,
+            },
+          ],
+        },
+      ]);
+      instance.clearSelection();
+      expect(instance.nodes).toMatchObject([
+        {
+          title: 'title',
+          isSelected: false,
+          children: [
+            {
+              title: 'title2',
+              isSelected: false,
+            },
+          ],
+        },
+      ]);
+    });
+
+    it('should not remove node if not selected', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes: [{ title: 'title' }] });
+      const treeObject = {
+        getSelected: () => [],
+        remove: (path: number[][]) => { if (path[0][0] === 0) instance.nodes = []; },
+      };
+      instance.setTree(treeObject);
+      instance.removeSelected();
+      expect(instance.nodes).toMatchObject([{ title: 'title' }]);
+    });
+  });
+
+  describe('updateNodeData()', () => {
+    it('should update the data for the selected node', () => {
+      const newData: ITreeNode<IDictionary> = { title: 'newTitle' };
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes: [{ title: 'title' }] });
+      const treeObject = {
+        updateNode: () => { instance.nodes[0] = { title: 'newTitle' }; },
+      };
+      instance.setTree(treeObject);
+      instance.updateNodeData(instance.nodes[0], newData);
+      expect(instance.nodes).toMatchObject([{ title: 'newTitle' }]);
+    });
+  });
+
+  describe('setNodes()', () => {
+    it('should define the nodes and set the isDraggable property to false', () => {
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', allowDragDrop: false });
+      instance.nodes = [{
+        title: 'title',
+        isDraggable: true,
+        children: [{ title: 'title2', isDraggable: true }],
+      }];
+      expect(instance.nodes[0].isDraggable).toBeFalsy();
+    });
+  });
+
+  describe('events', () => {
+    it('should call events', (done) => {
+      const node: ITreeNode<IDictionary> = { title: 'title' };
+      const nodes: ITreeNode<IDictionary>[] = [];
+      const position: ICursorPosition<IDictionary> = { node, placement: 'inside' };
+      let onNodeSelectCalled = false;
+      let onNodeClickCalled = false;
+      let onNodeDblClickCalled = false;
+      let onNodeDropCalled = false;
+      let onNodeCheckCalled = false;
+
+      const instance2 = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        nodes: [{ title: 'title' }],
+      });
+
+      instance2.nodeDrop(nodes, position);
+      expect(onNodeDropCalled).toBeFalsy();
+
+      instance2.nodeSelect(nodes);
+      expect(onNodeSelectCalled).toBeFalsy();
+
+      instance2.nodeClick(node);
+      expect(onNodeClickCalled).toBeFalsy();
+
+      instance2.nodeDblClick(node);
+      expect(onNodeDblClickCalled).toBeFalsy();
+
+      instance2.nodeCheck(node);
+      expect(onNodeCheckCalled).toBeFalsy();
+
+      const instance = new Tree({
+        name: 'tree',
+        component: 'ZdTree',
+        events: {
+          onNodeSelect: () => { onNodeSelectCalled = true; },
+          onNodeClick: () => { onNodeClickCalled = true; },
+          onNodeDblClick: () => { onNodeDblClickCalled = true; },
+          onNodeDrop: () => { onNodeDropCalled = true; },
+          onNodeCheck: () => { onNodeCheckCalled = true; },
+        },
+        nodes: [{ title: 'title' }],
+      });
+
+      instance.nodeDrop(nodes, position);
+      expect(onNodeDropCalled).toBeTruthy();
+
+      instance.nodeClick(node);
+      expect(onNodeClickCalled).toBeTruthy();
+
+      instance.nodeDblClick(node);
+      expect(onNodeDblClickCalled).toBeTruthy();
+
+      instance.nodeCheck(node);
+      expect(onNodeCheckCalled).toBeTruthy();
+
+      instance.nodeSelect(nodes);
+      setTimeout(() => {
+        expect(onNodeSelectCalled).toBeTruthy();
+        done();
+      }, 100);
+    });
+  });
+
+  describe('getNode', () => {
+    it('when called, should retrieve the node at the defined path', () => {
+      const nodes = [
+        {
+          title: 'Node 1',
+          children: [
+            { title: 'Node 1.1' },
+            { title: 'Node 1.2' },
+          ],
+        },
+        {
+          title: 'Node 2',
+          children: [
+            {
+              title: 'Node 2.1',
+              children: [
+                { title: 'Node 2.1.1' },
+              ],
+            },
+            { title: 'Node 2.2' },
+          ],
+        },
+      ];
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes });
+
+      expect(instance.getNode([0])?.title).toBe('Node 1');
+      expect(instance.getNode([1, 0])?.title).toBe('Node 2.1');
+      expect(instance.getNode([1, 0, 0])?.title).toBe('Node 2.1.1');
+    });
+
+    it('when called with an invalid path, should return undefined', () => {
+      const nodes = [
+        {
+          title: 'Node 1',
+          children: [
+            { title: 'Node 1.1' },
+            { title: 'Node 1.2' },
+          ],
+        },
+        {
+          title: 'Node 2',
+          children: [
+            {
+              title: 'Node 2.1',
+              children: [
+                { title: 'Node 2.1.1' },
+              ],
+            },
+            { title: 'Node 2.2', children: undefined },
+          ],
+        },
+      ];
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes });
+
+      const node = instance.getNode([2, 0]);
+
+      expect(node).toBeUndefined();
+      expect(instance.getNode([1, 1, 0])).toBeUndefined();
+      expect(instance.getNode([])).toBeUndefined();
+    });
+
+    it('when called with a node without children, should return undefined', () => {
+      const nodes = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes });
+      instance.nodes[0].children = undefined;
+
+      const node = instance.getNode([0, 0]);
+
+      expect(node).toBeUndefined();
+    });
+  });
+
+  describe('getParentNode', () => {
+    it('when called, should call tree getParentNode', () => {
+      const nodes = [
+        {
+          title: 'Node 1',
+          children: [
+            { title: 'Node 1.1' },
+            { title: 'Node 1.2' },
+          ],
+        },
+      ];
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes });
+      const fn = jest.fn();
+      instance.setTree({
+        getNode: fn,
+      });
+      const fakeNode = { ...nodes[0].children[0], path: [0, 1] };
+
+      instance.getParentNode(fakeNode);
+
+      expect(fn).toHaveBeenCalledWith([0]);
+    });
+
+    it('when called with a node without path, should return undefined', () => {
+      const nodes = [
+        { title: 'Node 1' },
+      ];
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes });
+      const fakeNode = {} as ITreeNode<IDictionary>;
+
+      instance.getParentNode(fakeNode);
+
+      expect(instance.getParentNode(fakeNode)).toBeUndefined();
+    });
+  });
+
+  describe('getCheckedNodes', () => {
+    it('when called, should retrieve the checked nodes', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+          children: [
+            { title: 'Node 1.1', data: { checked: true }, path: [0, 0] },
+            { title: 'Node 1.2' },
+          ],
+        },
+      ];
+      const instance = new Tree({ name: 'tree', component: 'ZdTree', nodes });
+      instance.setTree({
+        traverse: (cb: (node: any) => any) => {
+          [nodes[0], nodes[0].children[0], nodes[0].children[1]].forEach(cb);
+        },
+      });
+
+      expect(instance.getCheckedNodes()).toMatchObject([{ title: 'Node 1.1' }]);
+    });
+
+    it('when called using checkedField, should use the checkedField prop from data', () => {
+      '';
+
+      const nodes: any = [
+        {
+          title: 'Node 1',
+          children: [
+            { title: 'Node 1.1', data: { field: true }, path: [0, 0] },
+            { title: 'Node 1.2' },
+          ],
+        },
+      ];
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', checkedField: 'field', nodes,
+      });
+      instance.setTree({
+        traverse: (cb: (node: any) => any) => {
+          [nodes[0], nodes[0].children[0], nodes[0].children[1]].forEach(cb);
+        },
+      });
+
+      expect(instance.getCheckedNodes()).toMatchObject([{ title: 'Node 1.1' }]);
+    });
+  });
+
+  describe('reapplyConditions', () => {
+    it('when called with a node, should calculate and return the conditions for the node using the tree slots', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'afterTitleSlotText',
+        component: 'ZdText',
+        conditions: {
+          text: () => 'afterTitleSlot condition text',
+        },
+      };
+      const titleSlot = [{
+        name: 'titleSlotText',
+        component: 'ZdText',
+        conditions: {
+          cssStyle: {
+            color: () => 'red',
+          },
+        },
+      }];
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot, titleSlot,
+      });
+      const fakeTreeNode = { ...nodes[0], pathStr: '[0]' };
+      const applied = instance.reapplyConditions(fakeTreeNode);
+
+      expect(applied).toEqual({
+        afterTitleSlotText: { text: 'afterTitleSlot condition text' },
+        titleSlotText: { cssStyle: { color: 'red' } },
+      });
+    });
+
+    it('when called with a node, should calculate and return the conditions for the node from nested slot comps', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'afterTooltip',
+        component: 'ZdTooltip',
+        label: 'Tooltip',
+        bottom: true,
+        children: [
+          {
+            name: 'afterText',
+            component: 'ZdText',
+            conditions: {
+              text: () => 'afterText condition text',
+            },
+          },
+        ],
+      };
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot,
+      });
+      const fakeTreeNode = { ...nodes[0], pathStr: '[0]' };
+      const applied = instance.reapplyConditions(fakeTreeNode);
+
+      expect(applied).toEqual({
+        'afterTooltip.afterText': { text: 'afterText condition text' },
+      });
+    });
+
+    it('when called with a note without path, should return empty object', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'textComp',
+        component: 'ZdText',
+        conditions: {
+          text: () => 'condition text',
+        },
+      };
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot,
+      });
+      const fakePathlessNode = { ...nodes[0] };
+      const applied = instance.reapplyConditions(fakePathlessNode);
+
+      expect(applied).toEqual({});
+    });
+  });
+
+  describe('getSlotComponent', () => {
+    it('when called with nested components and nested conditions, should merge all of the children conditions', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const titleSlot = [{
+        name: 'titleSlotTooltip',
+        component: 'ZdTooltip',
+        children: [{
+          name: 'titleSlotText',
+          component: 'ZdText',
+          conditions: {
+            cssStyle: {
+              color: () => 'red',
+            },
+          },
+        }],
+      }];
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, titleSlot,
+      });
+      const fakeTreeNode = { ...nodes[0], pathStr: '[0]' };
+      instance.reapplyConditions(fakeTreeNode);
+
+      const newTitle = instance.getSlotComponent(titleSlot, fakeTreeNode);
+
+      expect(newTitle).toMatchObject([{
+        name: 'titleSlotTooltip_[0]',
+        component: 'ZdTooltip',
+        children: [{
+          name: 'titleSlotText_[0]',
+          component: 'ZdText',
+          cssStyle: {
+            color: 'red',
+          },
+          children: [],
+        }],
+      }]);
+    });
+
+    it('when called with undefined objects, should not throw', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'afterTitleSlotText',
+        component: 'ZdText',
+        conditions: {
+          text: () => 'afterTitleSlot condition text',
+        },
+      };
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot,
+      });
+      const fakeTreeNode = { ...nodes[0], pathStr: '[0]' };
+      instance.reapplyConditions(fakeTreeNode);
+
+      expect(() => instance.getSlotComponent([undefined] as any, fakeTreeNode)).not.toThrow();
+    });
+
+    it('when called with a node without path, should not throw', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'afterTitleSlotText',
+        component: 'ZdText',
+        conditions: {
+          text: () => 'afterTitleSlot condition text',
+        },
+      };
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot,
+      });
+      const fakePathlessNode = { ...nodes[0] };
+
+      expect(() => instance.getSlotComponent(afterTitleSlot, fakePathlessNode)).not.toThrow();
+    });
+
+    it('when called before applying the conditions, should only change the component name', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'afterTitleSlotText',
+        component: 'ZdText',
+        conditions: {
+          text: () => 'afterTitleSlot condition text',
+        },
+      };
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot,
+      });
+      const fakeTreeNode = { ...nodes[0], pathStr: '[0]' };
+      const newComp = instance.getSlotComponent(afterTitleSlot, fakeTreeNode);
+
+      expect(newComp).toMatchObject([{
+        name: 'afterTitleSlotText_[0]',
+        component: 'ZdText',
+        children: [],
+      }]);
+    });
+
+    it('when called, should merge a slot component with it\'s conditions', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'afterTitleSlotText',
+        component: 'ZdText',
+        conditions: {
+          text: () => 'afterTitleSlot condition text',
+        },
+      };
+
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot,
+      });
+      const fakeTreeNode = { ...nodes, pathStr: '[0]' };
+      instance.reapplyConditions(fakeTreeNode);
+
+      const newAfterTitle = instance.getSlotComponent(afterTitleSlot, fakeTreeNode);
+
+      expect(newAfterTitle).toMatchObject([{
+        name: 'afterTitleSlotText_[0]',
+        component: 'ZdText',
+        text: 'afterTitleSlot condition text',
+        children: [],
+      }]);
+
+      const getInstancesSpy = jest.spyOn(Metadata, 'getInstances').mockImplementation(() => [newAfterTitle]);
+
+      const newAfterTitle1 = instance.getSlotComponent(afterTitleSlot, fakeTreeNode);
+
+      const afterTitleSlot2 = { ...afterTitleSlot, name: 'afterTitleSlotText_[0]' };
+      instance.getSlotComponent(afterTitleSlot2, fakeTreeNode);
+
+      expect(newAfterTitle1).toMatchObject([{
+        name: 'afterTitleSlotText_[0]',
+        text: 'afterTitleSlot condition text',
+        children: [],
+      }]);
+
+      getInstancesSpy.mockClear();
+      getInstancesSpy.mockReset();
+    });
+
+    it('should call update instance when the action component already exists', () => {
+      const nodes: any = [
+        {
+          title: 'Node 1',
+        },
+      ];
+      const afterTitleSlot = {
+        name: 'afterTitleSlotText',
+        component: 'ZdText',
+      };
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, afterTitleSlot,
+      });
+      const fakeTreeNode = { ...nodes[0], pathStr: '[0]' };
+
+      const newAfterTitle = instance.getSlotComponent(afterTitleSlot, fakeTreeNode);
+      const spy = jest.spyOn(Metadata, 'updateInstance').mockReturnValue(newAfterTitle[0]);
+
+      const newAfterTitle2 = instance.getSlotComponent(afterTitleSlot, fakeTreeNode);
+
+      expect(newAfterTitle).toEqual(newAfterTitle2);
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('callDisableCheckbox', () => {
+    it('when called, should call disableCheckbox function', () => {
+      const nodes = [
+        { title: 'Node 1' },
+        { title: 'Node 2' },
+      ];
+      const disableCheckbox = jest.fn();
+      const instance = new Tree({
+        name: 'tree', component: 'ZdTree', nodes, disableCheckbox,
+      });
+
+      instance.callDisableCheckbox(instance.nodes[0]);
+      expect(disableCheckbox).toHaveBeenCalledWith({ node: instance.nodes[0], component: instance });
+
+      instance.callDisableCheckbox(instance.nodes[1]);
+      expect(disableCheckbox).toHaveBeenCalledWith({ node: instance.nodes[1], component: instance });
+
+      expect(disableCheckbox).toHaveBeenCalledTimes(2);
+    });
+  });
+});