added messages list, new client form, logic for client Apps plus others

public/libs/tabulator-master/test/unit/modules/DataTree.spec.js

@@ -0,0 +1,473 @@
+import Module from '../../../src/js/core/Module.js';
+import DataTree from '../../../src/js/modules/DataTree/DataTree.js';
+
+// Override the Module methods that interact with the table to avoid dependency issues
+const originalRegisterTableOption = Module.prototype.registerTableOption;
+Module.prototype.registerTableOption = function() {};
+
+const originalRegisterColumnOption = Module.prototype.registerColumnOption;
+Module.prototype.registerColumnOption = function() {};
+
+const originalRegisterComponentFunction = Module.prototype.registerComponentFunction;
+Module.prototype.registerComponentFunction = function() {};
+
+// Mock CoreFeature methods
+DataTree.prototype.subscribe = jest.fn();
+DataTree.prototype.registerDisplayHandler = jest.fn();
+DataTree.prototype.dispatchExternal = jest.fn();
+
+describe('DataTree', function(){
+	// Restore original Module methods after all tests
+	afterAll(() => {
+		Module.prototype.registerTableOption = originalRegisterTableOption;
+		Module.prototype.registerColumnOption = originalRegisterColumnOption;
+		Module.prototype.registerComponentFunction = originalRegisterComponentFunction;
+	});
+
+	// Test direct functionality without a complete table instance
+	describe('Functionality tests', function() {
+		test('initialize sets properties based on options', function(){
+			// Mock document methods for DOM element creation
+			const mockElement = {
+				classList: {
+					add: jest.fn()
+				},
+				innerHTML: '',
+				appendChild: jest.fn(),
+				tabIndex: 0
+			};
+			
+			const originalCreateElement = document.createElement;
+			document.createElement = jest.fn().mockReturnValue({...mockElement});
+			
+			// Create mock table with options
+			const mockTable = {
+				options: {
+					dataTree: true,
+					dataTreeChildField: "children",
+					dataTreeChildIndent: 15,
+					dataTreeBranchElement: true,
+					dataTreeStartExpanded: false,
+					movableRows: false
+				},
+				columnManager: {
+					getFirstVisibleColumn: jest.fn().mockReturnValue({
+						field: "name"  
+					})
+				}
+			};
+			
+			// Create the module instance
+			const dataTree = new DataTree(mockTable);
+			
+			// Call initialize
+			dataTree.initialize();
+			
+			// Check that properties were set correctly
+			expect(dataTree.field).toBe("children");
+			expect(dataTree.indent).toBe(15);
+			expect(dataTree.subscribe).toHaveBeenCalled();
+			expect(dataTree.registerDisplayHandler).toHaveBeenCalled();
+			
+			// Restore original createElement
+			document.createElement = originalCreateElement;
+		});
+
+		test('startOpen function is correctly configured', function(){
+			// Test with boolean option
+			const mockTableBoolean = {
+				options: {
+					dataTree: true,
+					dataTreeStartExpanded: true
+				}
+			};
+			
+			const dataTreeBoolean = new DataTree(mockTableBoolean);
+			dataTreeBoolean.options = jest.fn().mockReturnValue(false); // Mock options to prevent other dependency issues
+			
+			// Mock the initialize method to not require full initialization
+			const originalInitialize = dataTreeBoolean.initialize;
+			dataTreeBoolean.initialize = function() {
+				// Extract just the startOpen configuration part
+				switch(typeof this.table.options.dataTreeStartExpanded){
+					case "boolean":
+						this.startOpen = function(row, index){
+							return this.table.options.dataTreeStartExpanded;
+						};
+						break;
+				}
+			};
+			
+			dataTreeBoolean.initialize();
+			
+			// Should return true for any row
+			expect(dataTreeBoolean.startOpen({}, 0)).toBe(true);
+			
+			// Restore original method
+			dataTreeBoolean.initialize = originalInitialize;
+			
+			// Test with function option
+			const customFn = jest.fn().mockImplementation((row, index) => index > 1);
+			const mockTableFunction = {
+				options: {
+					dataTree: true,
+					dataTreeStartExpanded: customFn
+				}
+			};
+			
+			const dataTreeFunction = new DataTree(mockTableFunction);
+			dataTreeFunction.options = jest.fn().mockReturnValue(false);
+			
+			// Mock the initialize method
+			dataTreeFunction.initialize = function() {
+				switch(typeof this.table.options.dataTreeStartExpanded){
+					case "function":
+						this.startOpen = this.table.options.dataTreeStartExpanded;
+						break;
+				}
+			};
+			
+			dataTreeFunction.initialize();
+			
+			// Should use the provided function
+			expect(dataTreeFunction.startOpen).toBe(customFn);
+			expect(dataTreeFunction.startOpen({}, 2)).toBe(true);
+			expect(dataTreeFunction.startOpen({}, 0)).toBe(false);
+			
+			// Test with array option
+			const mockTableArray = {
+				options: {
+					dataTree: true,
+					dataTreeStartExpanded: [true, false, true]
+				}
+			};
+			
+			const dataTreeArray = new DataTree(mockTableArray);
+			dataTreeArray.options = jest.fn().mockReturnValue(false);
+			
+			// Mock the initialize method
+			dataTreeArray.initialize = function() {
+				// This is the relevant part from the actual initialize method
+				switch(typeof this.table.options.dataTreeStartExpanded){
+					default:
+						this.startOpen = function(row, index){
+							return this.table.options.dataTreeStartExpanded[index];
+						};
+						break;
+				}
+			};
+			
+			dataTreeArray.initialize();
+			
+			// Should return value from array based on index
+			expect(dataTreeArray.startOpen({}, 0)).toBe(true);
+			expect(dataTreeArray.startOpen({}, 1)).toBe(false);
+			expect(dataTreeArray.startOpen({}, 2)).toBe(true);
+		});
+
+		test('initializeRow sets up row.modules.dataTree correctly', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true, dataTreeChildField: "children"}
+			});
+			
+			// Set up required properties manually
+			dataTree.field = "children";
+			
+			// Mock the startOpen function to avoid dependencies
+			dataTree.startOpen = jest.fn().mockReturnValue(true);
+			
+			// Case 1: Row with children as array
+			const rowWithChildren = {
+				getData: jest.fn().mockReturnValue({
+					children: [{id: 1}, {id: 2}]
+				}),
+				modules: {},
+				getComponent: jest.fn().mockReturnValue({})
+			};
+			
+			dataTree.initializeRow(rowWithChildren);
+			
+			expect(rowWithChildren.modules.dataTree).toBeDefined();
+			expect(rowWithChildren.modules.dataTree.children).toBe(true);
+			expect(rowWithChildren.modules.dataTree.open).toBe(true);
+			
+			// Case 2: Row with children as object
+			const rowWithObjectChildren = {
+				getData: jest.fn().mockReturnValue({
+					children: {id: 1, name: "Child"}
+				}),
+				modules: {},
+				getComponent: jest.fn().mockReturnValue({})
+			};
+			
+			dataTree.initializeRow(rowWithObjectChildren);
+			
+			expect(rowWithObjectChildren.modules.dataTree).toBeDefined();
+			expect(rowWithObjectChildren.modules.dataTree.children).toBe(true);
+			
+			// Case 3: Row without children
+			const rowWithoutChildren = {
+				getData: jest.fn().mockReturnValue({
+					name: "No children"
+				}),
+				modules: {},
+				getComponent: jest.fn().mockReturnValue({})
+			};
+			
+			dataTree.initializeRow(rowWithoutChildren);
+			
+			expect(rowWithoutChildren.modules.dataTree).toBeDefined();
+			expect(rowWithoutChildren.modules.dataTree.children).toBe(false);
+		});
+
+		test('expandRow sets open to true and refreshes data', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true}
+			});
+			
+			// Mock methods
+			dataTree.refreshData = jest.fn();
+			dataTree.dispatchExternal = jest.fn();
+			
+			// Create a row with children
+			const row = {
+				modules: {
+					dataTree: {
+						children: true,
+						open: false,
+						index: 1
+					}
+				},
+				reinitialize: jest.fn(),
+				getComponent: jest.fn().mockReturnValue({})
+			};
+			
+			dataTree.expandRow(row);
+			
+			expect(row.modules.dataTree.open).toBe(true);
+			expect(row.reinitialize).toHaveBeenCalled();
+			expect(dataTree.refreshData).toHaveBeenCalledWith(true);
+			expect(dataTree.dispatchExternal).toHaveBeenCalledWith("dataTreeRowExpanded", expect.anything(), 1);
+		});
+
+		test('collapseRow sets open to false and refreshes data', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true}
+			});
+			
+			// Mock methods
+			dataTree.refreshData = jest.fn();
+			dataTree.dispatchExternal = jest.fn();
+			
+			// Create a row with children
+			const row = {
+				modules: {
+					dataTree: {
+						children: true,
+						open: true,
+						index: 1
+					}
+				},
+				reinitialize: jest.fn(),
+				getComponent: jest.fn().mockReturnValue({})
+			};
+			
+			dataTree.collapseRow(row);
+			
+			expect(row.modules.dataTree.open).toBe(false);
+			expect(row.reinitialize).toHaveBeenCalled();
+			expect(dataTree.refreshData).toHaveBeenCalledWith(true);
+			expect(dataTree.dispatchExternal).toHaveBeenCalledWith("dataTreeRowCollapsed", expect.anything(), 1);
+		});
+
+		test('toggleRow calls appropriate function based on open state', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true}
+			});
+			
+			// Mock methods
+			dataTree.expandRow = jest.fn();
+			dataTree.collapseRow = jest.fn();
+			
+			// Test with closed row
+			const closedRow = {
+				modules: {
+					dataTree: {
+						children: true,
+						open: false
+					}
+				}
+			};
+			
+			dataTree.toggleRow(closedRow);
+			expect(dataTree.expandRow).toHaveBeenCalledWith(closedRow);
+			expect(dataTree.collapseRow).not.toHaveBeenCalled();
+			
+			dataTree.expandRow.mockClear();
+			dataTree.collapseRow.mockClear();
+			
+			// Test with open row
+			const openRow = {
+				modules: {
+					dataTree: {
+						children: true,
+						open: true
+					}
+				}
+			};
+			
+			dataTree.toggleRow(openRow);
+			expect(dataTree.collapseRow).toHaveBeenCalledWith(openRow);
+			expect(dataTree.expandRow).not.toHaveBeenCalled();
+		});
+
+		test('isRowExpanded returns correct state', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true}
+			});
+			
+			const openRow = {
+				modules: {
+					dataTree: {
+						open: true
+					}
+				}
+			};
+			
+			const closedRow = {
+				modules: {
+					dataTree: {
+						open: false
+					}
+				}
+			};
+			
+			expect(dataTree.isRowExpanded(openRow)).toBe(true);
+			expect(dataTree.isRowExpanded(closedRow)).toBe(false);
+		});
+
+		test('getTreeParent returns parent component', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true}
+			});
+			
+			const parentComponent = {};
+			
+			const childRow = {
+				modules: {
+					dataTree: {
+						parent: {
+							getComponent: jest.fn().mockReturnValue(parentComponent)
+						}
+					}
+				}
+			};
+			
+			const orphanRow = {
+				modules: {
+					dataTree: {
+						parent: false
+					}
+				}
+			};
+			
+			expect(dataTree.getTreeParent(childRow)).toBe(parentComponent);
+			expect(dataTree.getTreeParent(orphanRow)).toBe(false);
+		});
+
+		test('getTreeChildren returns children correctly', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true}
+			});
+			
+			// In this modified approach, we'll directly mock the implementation of getTreeChildren
+			// instead of trying to modify Symbol.hasInstance which is read-only
+			const originalGetTreeChildren = dataTree.getTreeChildren;
+			
+			dataTree.getTreeChildren = jest.fn((row, component, recurse) => {
+				if (row === rowWithChildren) {
+					if (component) {
+						return [{ component: 1 }, { component: 2 }];
+					} else {
+						return [mockRow1, mockRow2];
+					}
+				}
+				return [];
+			});
+			
+			const mockRow1 = { id: 1 };
+			const mockRow2 = { id: 2 };
+			
+			// Row with pre-generated children
+			const rowWithChildren = {
+				modules: {
+					dataTree: {
+						children: [mockRow1, mockRow2]
+					}
+				}
+			};
+			
+			// Get children without component conversion
+			const childrenAsRows = dataTree.getTreeChildren(rowWithChildren, false, false);
+			expect(childrenAsRows.length).toBe(2);
+			expect(childrenAsRows[0]).toBe(mockRow1);
+			expect(childrenAsRows[1]).toBe(mockRow2);
+			
+			// Get children with component conversion
+			const childrenAsComponents = dataTree.getTreeChildren(rowWithChildren, true, false);
+			expect(childrenAsComponents.length).toBe(2);
+			expect(childrenAsComponents[0]).toEqual({ component: 1 });
+			expect(childrenAsComponents[1]).toEqual({ component: 2 });
+			
+			// Restore original method
+			dataTree.getTreeChildren = originalGetTreeChildren;
+		});
+
+		test('addTreeChildRow adds a child row correctly', function(){
+			// Create a dataTree instance with minimal options
+			const dataTree = new DataTree({
+				options: {dataTree: true}
+			});
+			
+			dataTree.field = "children";
+			dataTree.startOpen = jest.fn().mockReturnValue(true);
+			dataTree.initializeRow = jest.fn();
+			dataTree.layoutRow = jest.fn();
+			dataTree.refreshData = jest.fn();
+			
+			// Create a parent row without children initially
+			const row = {
+				data: {},
+				modules: {
+					dataTree: {
+						index: 1
+					}
+				},
+				getComponent: jest.fn().mockReturnValue({})
+			};
+			
+			// Add a child to the top
+			dataTree.addTreeChildRow(row, {id: 1, name: "Child 1"}, true);
+			
+			expect(row.data.children).toBeDefined();
+			expect(row.data.children.length).toBe(1);
+			expect(row.data.children[0].id).toBe(1);
+			expect(dataTree.initializeRow).toHaveBeenCalledWith(row);
+			expect(dataTree.layoutRow).toHaveBeenCalledWith(row);
+			expect(dataTree.refreshData).toHaveBeenCalledWith(true);
+			
+			// Add another child to the bottom
+			dataTree.addTreeChildRow(row, {id: 2, name: "Child 2"}, false);
+			
+			expect(row.data.children.length).toBe(2);
+			expect(row.data.children[1].id).toBe(2);
+		});
+	});
+});