@datarailsshared/dr_renderer 1.4.67 → 1.4.80

package/tests/highcharts_renderer.test.js

@@ -518,7 +518,7 @@ describe('highcharts_renderer', () => {
         beforeEach(() => {
             highchartsRenderer.enabledNewWidgetValueFormatting = false;
             highchartsRenderer.delimer = ' , ';
-            
+
             funcContext = {
                 y: 12345.678,
                 series: {
@@ -586,10 +586,10 @@ describe('highcharts_renderer', () => {
 
             it('should format value using pivot data aggregator when show_value is true', () => {
                 opts = { chartOptions: { label: { show_value: true } } };
-                
+
                 let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
                 let result = fn.call(funcContext);
-                
+
                 expect(highchartsRenderer.getSeriesNameInFormatterContext).toHaveBeenCalledWith(funcContext);
                 expect(highchartsRenderer.getColsInFormatterContext).toHaveBeenCalledWith(funcContext);
                 expect(mockPivotData.getAggregator).toHaveBeenCalled();
@@ -600,7 +600,7 @@ describe('highcharts_renderer', () => {
                 opts = { chartOptions: { label: { show_value: false } } };
                 let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
                 let result = fn.call(funcContext);
-                
+
                 expect(result).toBe('');
             });
 
@@ -716,9 +716,9 @@ describe('highcharts_renderer', () => {
             it('should return raw value when show_out_of_x_axis is true but percentage logic is not triggered', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            show_out_of_x_axis: true 
+                            show_out_of_x_axis: true
                         }
                     }
                 };
@@ -735,9 +735,9 @@ describe('highcharts_renderer', () => {
             it('should return raw value when show_out_of_data_series is true but percentage logic is not triggered', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            show_out_of_data_series: true 
+                            show_out_of_data_series: true
                         }
                     }
                 };
@@ -778,9 +778,9 @@ describe('highcharts_renderer', () => {
             it('should show only percentages without value when show_value is false but percentages are enabled', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: false,
-                            show_out_of_x_axis: true 
+                            show_out_of_x_axis: true
                         }
                     }
                 };
@@ -797,9 +797,9 @@ describe('highcharts_renderer', () => {
             it('should not add percentage when value is falsy', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            show_out_of_x_axis: true 
+                            show_out_of_x_axis: true
                         }
                     }
                 };
@@ -816,9 +816,9 @@ describe('highcharts_renderer', () => {
             it('should not add percentage when axisTotal is falsy', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            show_out_of_x_axis: true 
+                            show_out_of_x_axis: true
                         }
                     }
                 };
@@ -849,7 +849,7 @@ describe('highcharts_renderer', () => {
             it('should initialize cols to empty array when cols is falsy after array check', () => {
                 spyOn(lodash, 'isArray').and.returnValue(true);
                 highchartsRenderer.getColsInFormatterContext.and.returnValue(null);
-                
+
                 opts = { chartOptions: { label: { show_value: true } } };
                 let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
                 let result = fn.call(funcContext);
@@ -866,10 +866,10 @@ describe('highcharts_renderer', () => {
 
             it('should transform rows and cols for waterfall breakdown', () => {
                 opts = { chartOptions: { label: { show_value: true } } };
-                
+
                 let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
                 let result = fn.call(funcContext);
-                
+
                 expect(highchartsRenderer.transformRowsAndColsForBreakdown).toHaveBeenCalled();
                 expect(result).toBe('12,345.678');
             });
@@ -877,13 +877,13 @@ describe('highcharts_renderer', () => {
             it('should return raw value for waterfall breakdown when show_out_of_data_series is true but percentage logic is not triggered', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            show_out_of_data_series: true 
+                            show_out_of_data_series: true
                         }
                     }
                 };
-                
+
                 funcContext.y = 300;
                 mockPivotData.getRowKeys = jest.fn(() => ([['row1'], ['row2']]));
 
@@ -893,30 +893,30 @@ describe('highcharts_renderer', () => {
                     if (rows.length === 0 && cols.length > 0) return { value: () => 1200 };
                     return { value: () => 800 };
                 });
-                
+
                 let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
                 let result = fn.call(funcContext);
-                
+
                 expect(result).toBe('300');
             });
 
             it('should calculate percentage using dataSeriesTotal when axisTotal is falsy (waterfall breakdown)', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: false,
-                            show_out_of_data_series: true 
+                            show_out_of_data_series: true
                         }
                     }
                 };
-                
+
                 funcContext.y = 200; // value = 200
                 mockPivotData.getRowKeys = jest.fn(() => ([['row1'], ['row2']]));
 
                 let callCount = 0;
                 mockPivotData.getAggregator = jest.fn((rows, cols) => {
                     callCount++;
-                    
+
                     if (rows.length === 1) {
                         return { value: () => 400 };
                     }
@@ -935,16 +935,16 @@ describe('highcharts_renderer', () => {
 
             it('should not add percentage when dataSeriesTotal is falsy (non-waterfall breakdown)', () => {
                 funcContext.series.options.className = 'regularSeries';
-                
+
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: false,
-                            show_out_of_data_series: true 
+                            show_out_of_data_series: true
                         }
                     }
                 };
-                
+
                 funcContext.y = 200;
 
                 mockPivotData.getAggregator = jest.fn((rows, cols) => {
@@ -985,7 +985,7 @@ describe('highcharts_renderer', () => {
             it('should handle empty options gracefully for drill-down pie', () => {
                 let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, {}, true);
                 let result = fn.call(funcContext);
-                
+
                 expect(result).toBe('12,345.678');
             });
         });
@@ -994,9 +994,9 @@ describe('highcharts_renderer', () => {
             it('should fallback to raw value formatting when useUnitAbbreviation is false and getFormattedNumber returns abbreviated value', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            useUnitAbbreviation: false 
+                            useUnitAbbreviation: false
                         }
                     }
                 };
@@ -1012,9 +1012,9 @@ describe('highcharts_renderer', () => {
             it('should fallback to raw value formatting when useUnitAbbreviation is true and getFormattedNumber returns abbreviated value', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            useUnitAbbreviation: true 
+                            useUnitAbbreviation: true
                         }
                     }
                 };
@@ -1030,9 +1030,9 @@ describe('highcharts_renderer', () => {
             it('should fallback to raw value formatting when getFormattedNumber returns M-abbreviated value regardless of useUnitAbbreviation setting', () => {
                 opts = {
                     chartOptions: {
-                        label: { 
+                        label: {
                             show_value: true,
-                            useUnitAbbreviation: false 
+                            useUnitAbbreviation: false
                         }
                     }
                 };
@@ -8188,36 +8188,6 @@ describe('highcharts_renderer', () => {
             );
         });
 
-        it('should return no data result if series is empty', () => {
-            const chartOptions = {
-                chart: {},
-                series: [{ data: [] }, { data: [] }, {}],
-            };
-            const options = {};
-            const noDataFnSpy = jest.spyOn(highchartsRenderer, 'getNoDataResult').mockImplementation(() => {});
-
-            highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
-
-            expect(noDataFnSpy).toHaveBeenCalled();
-            expect(options.error_has_occurred).toBeTruthy();
-            expect(options.error_params).toBe(highchartsRenderer.widgetPlaceholders.nodata);
-        });
-
-        it('should return too much data result if series is too long', () => {
-            const chartOptions = {
-                chart: {},
-                series: [{ data: new Array(1000) }, { data: new Array(1000) }, {}],
-            };
-            const options = {};
-            const noDataFnSpy = jest.spyOn(highchartsRenderer, 'getNoDataResult').mockImplementation(() => {});
-
-            highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
-
-            expect(noDataFnSpy).toHaveBeenCalled();
-            expect(options.error_has_occurred).toBeTruthy();
-            expect(options.error_params).toBe(highchartsRenderer.widgetPlaceholders.tooMuchData);
-        });
-
         it('should set hcInstance on options with chart object for graph table renderer to use', () => {
             jest.useFakeTimers();
             jest.spyOn(Highcharts, 'chart').mockImplementation(() => ({ chart: true }));
@@ -8235,40 +8205,330 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe('Function getNoDataResult', () => {
-        const container = $('<div class="noData-box"></div>');
+    describe('Error Throwing Functionality', () => {
+        const {
+            NoDataError,
+            TooMuchDataError,
+            DataConflictError,
+            GaugeConfigurationError,
+            BaseRendererError,
+            GenericRenderingError,
+            GenericComputationalError
+        } = require('../src/errors');
 
-        it('should return no data html', () => {
-            const placeholderMeta = highchartsRenderer.widgetPlaceholders.nodata;
-            const expected = container.clone().html(highchartsRenderer.getWidgetPlaceholder(placeholderMeta));
-            expect(highchartsRenderer.getNoDataResult()).toEqual(expected);
+        beforeEach(() => {
+            jest.clearAllMocks();
         });
 
-        it('should return too much data html', () => {
-            const placeholderMeta = highchartsRenderer.widgetPlaceholders.tooMuchData;
-            const expected = container.clone().html(highchartsRenderer.getWidgetPlaceholder(placeholderMeta));
-            expect(highchartsRenderer.getNoDataResult(true)).toEqual(expected);
+        afterAll(() => {
+            jest.restoreAllMocks();
         });
 
-    });
+        describe('ptCreateElementAndDraw - Error Throwing', () => {
+            it('should throw NoDataError when series is empty and not onlyText', () => {
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: [] }, { data: [] }, {}],
+                };
+                const options = {};
+
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).toThrow(NoDataError);
+            });
+
+            it('should throw TooMuchDataError when series has too much data', () => {
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: new Array(1000) }, { data: new Array(1000) }, {}],
+                };
+                const options = {};
+
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).toThrow(TooMuchDataError);
+            });
+
+            it('should not throw errors when onlyText is true even if no data', () => {
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: [] }],
+                    onlyText: true,
+                };
+                const options = {};
+
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).not.toThrow();
+            });
+
+            it('should process normally when series has valid data', () => {
+                jest.spyOn(Highcharts, 'chart').mockImplementation(() => ({ chart: true }));
+                jest.useFakeTimers();
+
+                const chartOptions = {
+                    chart: {},
+                    series: [{ data: [1, 2, 3] }],
+                };
+                const options = {};
+
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).not.toThrow();
+
+                jest.runAllTimers();
+                jest.restoreAllMocks();
+                jest.useRealTimers();
+            });
+        });
+
+        describe('Data Conflict Error Throwing', () => {
+            it('should throw DataConflictError when categories are below minimum in waterfall chart', () => {
+                const options = {
+                    isBreakdown: true,
+                    uniqueCategories: ['A', 'B'], // Only 2 categories
+                    minCategories: 5,
+                    maxCategories: 10
+                };
+
+                expect(() => {
+                    throw new DataConflictError({
+                        isBreakdown: options.isBreakdown,
+                        uniqueCategories: options.uniqueCategories,
+                        minCategories: options.minCategories,
+                        maxCategories: options.maxCategories
+                    });
+                }).toThrow(DataConflictError);
+            });
+
+            it('should throw DataConflictError when categories exceed maximum in waterfall chart', () => {
+                const uniqueCategories = new Array(15).fill(0).map((_, i) => `Category${i}`); // 15 categories
+                const options = {
+                    isBreakdown: false,
+                    uniqueCategories,
+                    minCategories: 3,
+                    maxCategories: 10
+                };
+
+                expect(() => {
+                    throw new DataConflictError({
+                        isBreakdown: options.isBreakdown,
+                        uniqueCategories: options.uniqueCategories,
+                        minCategories: options.minCategories,
+                        maxCategories: options.maxCategories
+                    });
+                }).toThrow(DataConflictError);
+            });
+
+            it('should create DataConflictError with correct options for breakdown scenario', () => {
+                const options = {
+                    isBreakdown: true,
+                    uniqueCategories: ['A'],
+                    minCategories: 5,
+                    maxCategories: 10
+                };
+
+                try {
+                    throw new DataConflictError(options);
+                } catch (error) {
+                    expect(error).toBeInstanceOf(DataConflictError);
+                    expect(error.code).toBe(5);
+                    expect(error.title).toBe('Data Conflict');
+                    expect(error.options).toEqual(options);
+                    expect(error.options.isBreakdown).toBe(true);
+                    expect(error.options.uniqueCategories).toEqual(['A']);
+                    expect(error.options.minCategories).toBe(5);
+                    expect(error.options.maxCategories).toBe(10);
+                }
+            });
+
+            it('should create DataConflictError with correct options for walkthrough scenario', () => {
+                const options = {
+                    isBreakdown: false,
+                    uniqueCategories: ['A', 'B', 'C'],
+                    minCategories: 5,
+                    maxCategories: 8
+                };
+
+                try {
+                    throw new DataConflictError(options);
+                } catch (error) {
+                    expect(error).toBeInstanceOf(DataConflictError);
+                    expect(error.code).toBe(5);
+                    expect(error.title).toBe('Data Conflict');
+                    expect(error.options).toEqual(options);
+                    expect(error.options.isBreakdown).toBe(false);
+                }
+            });
+        });
 
-    describe('Function getWidgetPlaceholder', () => {
-        const titleSelector = '.noData-title';
-        const imageSelector = '.noData-image';
-        const textSelector = '.noData-text';
+        describe('Gauge Configuration Error Throwing', () => {
+            it('should create GaugeConfigurationError with correct properties', () => {
+                try {
+                    throw new GaugeConfigurationError();
+                } catch (error) {
+                    expect(error).toBeInstanceOf(GaugeConfigurationError);
+                    expect(error.code).toBe(6);
+                    expect(error.title).toBe('Please configure goal and needle');
+                    expect(error.options).toEqual({});
+                }
+            });
 
-        it('should return default placeholder when no data is provided', () => {
-            const placeholder = highchartsRenderer.getWidgetPlaceholder();
-            const defaultPlaceholder = '<div class="noData"><i class="noData-image"></i> no data</div>';
-            expect(placeholder[0].outerHTML).toEqual(defaultPlaceholder);
+            it('should be instance of BaseRendererError', () => {
+                const error = new GaugeConfigurationError();
+                expect(error).toBeInstanceOf(require('../src/errors').BaseRendererError);
+            });
         });
 
-        it('should return placeholder html when data is provided', () => {
-            Object.entries(highchartsRenderer.widgetPlaceholders).forEach(([, value]) => {
-                const placeholder = highchartsRenderer.getWidgetPlaceholder(value)[0];
-                expect(placeholder.querySelector(titleSelector).innerHTML).toEqual(value.title);
-                expect(placeholder.querySelector(imageSelector).classList.contains(value.class)).toBeTruthy();
-                expect(placeholder.querySelector(textSelector).innerHTML).toEqual(value.text);
+        describe('Error handling in rhPivotView functions (testing private _handleComputationalError and _handleRenderingError)', () => {
+            beforeEach(() => {
+                jest.spyOn(console, 'error').mockImplementation(() => {});
+            });
+
+            afterEach(() => {
+                jest.restoreAllMocks();
+            });
+
+            describe('Natural error conditions (testing private error handlers indirectly)', () => {
+                it('should handle too much data error correctly', () => {
+                    // Create dataset that exceeds MAX_ROWS_FOR_SHOW_RESULTS to trigger TooMuchDataError
+                    const largeRowData = new Array(highchartsRenderer.MAX_ROWS_FOR_SHOW_RESULTS + 1)
+                        .fill({ field1: 'value1', field2: 'value2' });
+                    
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(largeRowData, options);
+                    }).toThrow(TooMuchDataError);
+                });
+
+                it('should return empty object for too much data when onlyOptions is true', () => {
+                    // Create dataset that exceeds MAX_ROWS_FOR_SHOW_RESULTS
+                    const largeRowData = new Array(highchartsRenderer.MAX_ROWS_FOR_SHOW_RESULTS + 1)
+                        .fill({ field1: 'value1', field2: 'value2' });
+                    
+                    const options = {
+                        onlyOptions: true,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    const result = highchartsRenderer.rhPivotView(largeRowData, options);
+                    expect(result).toEqual({});
+                });
+
+                it('should handle no data error correctly', () => {
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    // Empty rowData should trigger NoDataError
+                    expect(() => {
+                        highchartsRenderer.rhPivotView([], options);
+                    }).toThrow(NoDataError);
+                });
+
+                it('should return empty object for no data when onlyOptions is true', () => {
+                    const options = {
+                        onlyOptions: true,
+                        rendererOptions: {},
+                        renderer: jest.fn()
+                    };
+
+                    const result = highchartsRenderer.rhPivotView([], options);
+                    expect(result).toEqual({});
+                });
+
+                it('should handle renderer errors correctly', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    const genericError = new Error('Renderer failed');
+                    
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw genericError;
+                        })
+                    };
+
+                    // Generic errors from renderer should be wrapped in GenericRenderingError
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, options);
+                    }).toThrow(GenericRenderingError);
+                });
+
+                it('should return empty object for renderer errors when onlyOptions is true', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    const genericError = new Error('Renderer failed');
+                    
+                    const options = {
+                        onlyOptions: true,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw genericError;
+                        })
+                    };
+
+                    const result = highchartsRenderer.rhPivotView(rowData, options);
+                    expect(result).toEqual({});
+                });
+
+                it('should re-throw BaseRendererError instances from renderer unchanged', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    const originalError = new NoDataError();
+                    
+                    const options = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw originalError;
+                        })
+                    };
+
+                    // BaseRendererError instances should be re-thrown unchanged
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, options);
+                    }).toThrow(NoDataError);
+                    
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, options);
+                    }).toThrow(originalError);
+                });
+
+                it('should handle null/undefined from renderer as GenericRenderingError', () => {
+                    const rowData = [{ field1: 'value1', field2: 'value2' }];
+                    
+                    // Test null
+                    const nullOptions = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw null;
+                        })
+                    };
+
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, nullOptions);
+                    }).toThrow(GenericRenderingError);
+
+                    const undefinedOptions = {
+                        onlyOptions: false,
+                        rendererOptions: {},
+                        renderer: jest.fn().mockImplementation(() => {
+                            throw undefined;
+                        })
+                    };
+
+                    expect(() => {
+                        highchartsRenderer.rhPivotView(rowData, undefinedOptions);
+                    }).toThrow(GenericRenderingError);
+                });
             });
         });
     });

package/tests/mock/widgets.json

@@ -314,7 +314,6 @@
         },
         "seriesOptions": []
       },
-      "error_params": null,
       "chart_title": "New Widget234",
       "chartLabels": {
         "legend": "Data series",
@@ -371,8 +370,7 @@
           "is_end_of_period": true,
           "is_formatting_by_aggregation_method": true
         }
-      ],
-      "error_has_occurred": false
+      ]
     },
     "vals": [
       {

package/tsconfig.json

@@ -10,6 +10,6 @@
         "emitDeclarationOnly": true,
         "strict": true
     },
-    "include": ["./src/graph-table-renderer.js"],
+    "include": ["./src/graph-table-renderer.js", "./src/errors.js"],
     "exclude": ["node_modules"]
 }

package/tsconfig.tsbuildinfo

@@ -1,6 +1,7 @@
 {
     "root": [
-        "./src/graph-table-renderer.js"
+        "./src/graph-table-renderer.js",
+        "./src/errors.js"
     ],
     "version": "5.9.2"
 }