@datarailsshared/dr_renderer 1.4.65 → 1.4.78

package/tests/highcharts_renderer.test.js

@@ -511,19 +511,559 @@ describe('highcharts_renderer', () => {
     });
 
     describe('function defaultDataLabelFormatter', () => {
+        let mockPivotData;
         let funcContext;
         let opts;
 
         beforeEach(() => {
             highchartsRenderer.enabledNewWidgetValueFormatting = false;
-            funcContext = { y: '12345.678' };
-            opts = {}
+            highchartsRenderer.delimer = ' , ';
+
+            funcContext = {
+                y: 12345.678,
+                series: {
+                    name: 'TestSeries',
+                    userOptions: {},
+                    options: {}
+                },
+                point: {
+                    name: 'TestPoint',
+                    options: {}
+                }
+            };
+            opts = {};
+
+            mockPivotData = {
+                rowAttrs: ['row1'],
+                colAttrs: ['col1'],
+                getRowKeys: jest.fn(() => [['row1'], ['row2']]),
+                getAggregator: jest.fn(() => ({
+                    value: () => 1000
+                }))
+            };
+
+            spyOn(highchartsRenderer, 'getSeriesNameInFormatterContext').and.returnValue('TestSeries');
+            spyOn(highchartsRenderer, 'getColsInFormatterContext').and.returnValue(['col1']);
+            spyOn(highchartsRenderer, 'getOthersName').and.returnValue('Others');
+            spyOn(highchartsRenderer, 'getDrOthersInAxisState').and.returnValue({});
+            spyOn(highchartsRenderer, 'transformRowsAndColsForBreakdown').and.returnValue({
+                rows: ['row1'],
+                cols: ['col1']
+            });
+            spyOn(highchartsRenderer, 'replaceDrOthersKeys');
+            spyOn(highchartsRenderer, 'selfStartsWith').and.returnValue(false);
+
+            global.$ = {
+                pivotUtilities: {
+                    getFormattedNumber: jest.fn(() => '1,234.56')
+                }
+            };
         });
 
-        it('should return local string if there are no pivotData', () => {
-            let fn = highchartsRenderer.defaultDataLabelFormatter(null, {})
-            let result = fn.call(funcContext)
-            expect(result).toBe('12,345.678');
+        describe('No pivotData is provided', () => {
+            it('should return formatted number as local string', () => {
+                let fn = highchartsRenderer.defaultDataLabelFormatter(null, {});
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should handle unit sign removal when labelOptions are provided', () => {
+                const labelOptions = { useUnitAbbreviation: false };
+                opts = { chartOptions: { label: labelOptions } };
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(null, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('pivotData is provided', () => {
+            beforeEach(() => {
+                funcContext.y = 1234.56;
+            });
+
+            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();
+                expect(result).toBe('1,234.56');
+            });
+
+            it('should return empty string when show_value is false and not drill-down pie', () => {
+                opts = { chartOptions: { label: { show_value: false } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('');
+            });
+
+            it('should handle empty row attributes', () => {
+                mockPivotData.rowAttrs = [];
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('1,234.56');
+            });
+
+            it('should handle totalSeries className', () => {
+                funcContext.series.options.className = 'totalSeries';
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('1,234.56');
+            });
+
+            it('should handle trendSeries className', () => {
+                funcContext.series.options.className = 'trendSeries';
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('1,234.56');
+            });
+        });
+
+        describe('Drill-down pie chart scenarios', () => {
+            beforeEach(() => {
+                funcContext.y = 500;
+            });
+
+            it('should handle drill-down pie when series name starts with "Series "', () => {
+                highchartsRenderer.selfStartsWith.and.returnValue(true);
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('Series 1');
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.selfStartsWith).toHaveBeenCalledWith('Series 1', 'Series ');
+                expect(result).toBe('500');
+            });
+
+            it('should use point name for columns when cols is null in drill-down pie', () => {
+                highchartsRenderer.getColsInFormatterContext.and.returnValue(null);
+                funcContext.point.name = 'DrillDownPoint';
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('500');
+            });
+
+            it('should swap rows and cols for drill-down pie when series name does not start with "Series "', () => {
+                highchartsRenderer.selfStartsWith.and.returnValue(false);
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('CustomSeries');
+
+                opts = { chartOptions: {} };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts, true);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('500');
+            });
+        });
+
+        describe('Delta column handling', () => {
+            it('should replace variant name when delta column field is series', () => {
+                opts = {
+                    chartOptions: {
+                        label: { show_value: true },
+                        delta_column: {
+                            field: 'series',
+                            name: 'test_variant'
+                        }
+                    }
+                };
+
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('test_variant' + highchartsRenderer.delimer + 'other');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should handle variant name matching when series name differs by underscores from delta column name', () => {
+                opts = {
+                    chartOptions: {
+                        label: { show_value: true },
+                        delta_column: {
+                            field: 'series',
+                            name: 'test_variant'
+                        }
+                    }
+                };
+
+                highchartsRenderer.getSeriesNameInFormatterContext.and.returnValue('testvariant' + highchartsRenderer.delimer + 'other');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('Label options handling', () => {
+            it('should return raw value when show_out_of_x_axis is true but percentage logic is not triggered', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 1000 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('250');
+            });
+
+            it('should return raw value when show_out_of_data_series is true but percentage logic is not triggered', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 200;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 800 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('200');
+            });
+
+            it('should return raw value when both percentage options are enabled but percentage logic is not triggered', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                let callCount = 0;
+                mockPivotData.getAggregator = jest.fn(() => {
+                    callCount++;
+                    return { value: () => callCount === 1 ? 1000 : 800 };
+                });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('250');
+            });
+
+            it('should show only percentages without value when show_value is false but percentages are enabled', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: false,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 1000 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('(25%)');
+            });
+
+            it('should not add percentage when value is falsy', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 0;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 1000 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('0');
+            });
+
+            it('should not add percentage when axisTotal is falsy', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            show_out_of_x_axis: true
+                        }
+                    }
+                };
+
+                funcContext.y = 250;
+                mockPivotData.getAggregator = jest.fn(() => ({ value: () => 0 }));
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('250');
+            });
+        });
+
+        describe('Object column handling', () => {
+            it('should extract name property from object columns', () => {
+                highchartsRenderer.getColsInFormatterContext.and.returnValue({ name: 'ObjectColumn' });
+
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('Column initialization handling', () => {
+            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);
+
+                expect(result).toBe('12,345.678');
+                expect(lodash.isArray).toHaveBeenCalledWith(null);
+            });
+        });
+
+        describe('Waterfall breakdown handling', () => {
+            beforeEach(() => {
+                funcContext.series.options.className = 'waterfallBreakdown';
+            });
+
+            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');
+            });
+
+            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: {
+                            show_value: true,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 300;
+                mockPivotData.getRowKeys = jest.fn(() => ([['row1'], ['row2']]));
+
+                let callCount = 0;
+                mockPivotData.getAggregator = jest.fn((rows, cols) => {
+                    if (rows.length === 1) return { value: () => 400 };
+                    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: {
+                            show_value: false,
+                            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 };
+                    }
+                    if (rows.length === 0 && cols.length > 0) {
+                        return { value: () => 0 };
+                    }
+
+                    return { value: () => 200 };
+                });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('(25%)');
+            });
+
+            it('should not add percentage when dataSeriesTotal is falsy (non-waterfall breakdown)', () => {
+                funcContext.series.options.className = 'regularSeries';
+
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: false,
+                            show_out_of_data_series: true
+                        }
+                    }
+                };
+
+                funcContext.y = 200;
+
+                mockPivotData.getAggregator = jest.fn((rows, cols) => {
+                    if (cols.length === 0) {
+                        return { value: () => 0 };
+                    }
+                    return { value: () => 200 };
+                });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('');
+            });
+        });
+
+        describe('Error handling', () => {
+            it('should fallback to basic formatting when aggregator throws error', () => {
+                mockPivotData.getAggregator = jest.fn(() => { throw new Error('Test error'); });
+
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should handle null columns gracefully', () => {
+                highchartsRenderer.getColsInFormatterContext.and.returnValue(null);
+
+                opts = { chartOptions: { label: { show_value: true } } };
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            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');
+            });
+        });
+
+        describe('Unit abbreviation options (fallback behavior)', () => {
+            it('should fallback to raw value formatting when useUnitAbbreviation is false and getFormattedNumber returns abbreviated value', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            useUnitAbbreviation: false
+                        }
+                    }
+                };
+
+                jest.spyOn(global.$.pivotUtilities, 'getFormattedNumber').mockReturnValue('12.5K');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should fallback to raw value formatting when useUnitAbbreviation is true and getFormattedNumber returns abbreviated value', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            useUnitAbbreviation: true
+                        }
+                    }
+                };
+
+                jest.spyOn(global.$.pivotUtilities, 'getFormattedNumber').mockReturnValue('12.5K');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+
+            it('should fallback to raw value formatting when getFormattedNumber returns M-abbreviated value regardless of useUnitAbbreviation setting', () => {
+                opts = {
+                    chartOptions: {
+                        label: {
+                            show_value: true,
+                            useUnitAbbreviation: false
+                        }
+                    }
+                };
+
+                jest.spyOn(global.$.pivotUtilities, 'getFormattedNumber').mockReturnValue('1.2M');
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(result).toBe('12,345.678');
+            });
+        });
+
+        describe('Others name handling', () => {
+            it('should handle others name replacement', () => {
+                opts = {
+                    total_value_options: { some: 'option' },
+                    chartOptions: { label: { show_value: true } }
+                };
+
+                highchartsRenderer.getOthersName.and.returnValue('CustomOthers');
+                highchartsRenderer.getDrOthersInAxisState.and.returnValue({ cols: true });
+
+                let fn = highchartsRenderer.defaultDataLabelFormatter(mockPivotData, opts);
+                let result = fn.call(funcContext);
+
+                expect(highchartsRenderer.getOthersName).toHaveBeenCalledWith(opts);
+                expect(highchartsRenderer.getDrOthersInAxisState).toHaveBeenCalledWith(mockPivotData, 'CustomOthers');
+                expect(highchartsRenderer.replaceDrOthersKeys).toHaveBeenCalled();
+                expect(result).toBe('12,345.678');
+            });
         });
     });
 
@@ -7648,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 }));
@@ -7695,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 = {};
 
-    describe('Function getWidgetPlaceholder', () => {
-        const titleSelector = '.noData-title';
-        const imageSelector = '.noData-image';
-        const textSelector = '.noData-text';
+                expect(() => {
+                    highchartsRenderer.ptCreateElementAndDraw(chartOptions, options);
+                }).toThrow(NoDataError);
+            });
 
-        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 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);
+                }
+            });
         });
 
-        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('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 be instance of BaseRendererError', () => {
+                const error = new GaugeConfigurationError();
+                expect(error).toBeInstanceOf(require('../src/errors').BaseRendererError);
+            });
+        });
+
+        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);
+                });
             });
         });
     });