@datarailsshared/dr_renderer 1.2.295 → 1.2.297

package/tests/highcharts_renderer.test.js

@@ -1,6 +1,6 @@
 import * as JQuery from "jquery";
 import * as lodash from 'lodash';
-import * as moment from 'moment';
+import moment from 'moment/min/moment.min';
 import tables from './mock/tables.json';
 import initPivotTable from "../src/pivottable";
 import initDRPivotTable from "../src/dr_pivottable";
@@ -380,19 +380,117 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe('function isSystemField', () => {
-        it('system name', () => {
-            const field = {
-                name: 'Doc_ID'
+    describe('function defaultValueLabelsFormatter', () => {
+        let funcContext;
+
+        beforeEach(() => {
+            funcContext = { value: '12345.678' };
+        });
+
+        it('should return formatted number by aggregator', () => {
+            const format = '"$"#,###.##';
+            let pivotData = {
+                getAggregator: () => {
+                    let aggregator = highchartsRenderer.rhPivotAggregatorSum([''], format, true, {}, {});
+                    return aggregator({}, '', '');
+                }
             };
-            expect(highchartsRenderer.isSystemField(field)).toBe(true);
+            let defaultValueLabelsFormatterFn = highchartsRenderer.defaultValueLabelsFormatter(pivotData, {})
+            let result = defaultValueLabelsFormatterFn.call(funcContext)
+            expect(result).toBe('$12,345.68');
         });
 
-        it('not system name', () => {
-            const field = {
-                name: 'field name'
+        it('should return local string if there are no pivotData', () => {
+            let defaultValueLabelsFormatterFn = highchartsRenderer.defaultValueLabelsFormatter(null, {})
+            let result = defaultValueLabelsFormatterFn.call(funcContext)
+            expect(result).toBe('12,345.678');
+        });
+    });
+
+    describe('function persantageValueLabelsFormatter', () => {
+        it('should return local string with %', () => {
+            let funcContext = { value: '12345.678' };
+            let persantageValueLabelsFormatterFn = highchartsRenderer.persantageValueLabelsFormatter(null, {})
+            let result = persantageValueLabelsFormatterFn.call(funcContext)
+            expect(result).toBe('1,234,567.8%');
+        });
+    });
+
+    describe('function pieDataLabelFormatter', () => {
+        let funcContext;
+        let opts;
+
+        beforeEach(() => {
+            spyOn(highchartsRenderer, 'defaultDataLabelFormatter').and.returnValue(function() { return this.value })
+            funcContext = {
+                value: '12345.678',
+                point: {
+                    color: 'red',
+                    name: 'test',
+                    percentage: 12.3456,
+                }
             };
-            expect(highchartsRenderer.isSystemField(field)).toBe(false);
+            opts = {
+                chartOptions: {
+                    label_pie: {
+                        use_area_color: false,
+                        show_percentage_in_labels: false,
+                        show_value_in_labels: false,
+                    }
+                }
+            }
+        });
+
+        it('should return null if value is nor defined', () => {
+            highchartsRenderer.defaultDataLabelFormatter.and.returnValue(() => null);
+            let func = highchartsRenderer.pieDataLabelFormatter(null, opts);
+            let result = func.call(funcContext);
+            expect(result).toBe(null);
+        });
+
+        it('should present only name with area color if only use_area_color option enabled', () => {
+            opts.chartOptions.label_pie.use_area_color = true;
+            let func = highchartsRenderer.pieDataLabelFormatter(null, opts);
+            let result = func.call(funcContext);
+            expect(result).toBe('<b><span style="color: red;">test</span><span>\u200E: </span></b>');
+        });
+
+        it('should present only name and value if only show_value_in_labels option enabled', () => {
+            opts.chartOptions.label_pie.show_value_in_labels = true;
+            let func = highchartsRenderer.pieDataLabelFormatter(null, opts);
+            let result = func.call(funcContext);
+            expect(result).toBe('<b><span >test</span><span>\u200E: 12345.678</span></b>');
+        });
+
+        it('should present only name and percentage if only show_percentage_in_labels option enabled', () => {
+            opts.chartOptions.label_pie.show_percentage_in_labels = true;
+            let func = highchartsRenderer.pieDataLabelFormatter(null, opts);
+            let result = func.call(funcContext);
+            expect(result).toBe('<b><span >test</span><span>\u200E: (12.35%)</span></b>');
+        });
+
+        it('should present vale + name + percentage if only % and value options enabled', () => {
+            opts.chartOptions.label_pie.show_percentage_in_labels = true;
+            opts.chartOptions.label_pie.show_value_in_labels = true;
+            let func = highchartsRenderer.pieDataLabelFormatter(null, opts);
+            let result = func.call(funcContext);
+            expect(result).toBe('12345.678<br><b><span >test</span><span>\u200E: (12.35%)</span></b>');
+        });
+    });
+
+    describe('function defaultDataLabelFormatter', () => {
+        let funcContext;
+        let opts;
+
+        beforeEach(() => {
+            funcContext = { y: '12345.678' };
+            opts = {}
+        });
+
+        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');
         });
     });
 
@@ -1042,6 +1140,22 @@ describe('highcharts_renderer', () => {
         });
     });
 
+    describe('function isSystemField', () => {
+        it('system name', () => {
+            const field = {
+                name: 'Doc_ID'
+            };
+            expect(highchartsRenderer.isSystemField(field)).toBe(true);
+        });
+
+        it('not system name', () => {
+            const field = {
+                name: 'field name'
+            };
+            expect(highchartsRenderer.isSystemField(field)).toBe(false);
+        });
+    });
+
     describe('function getFieldColorClass', () => {
         it('should return "green_field" if field is not a system field and not mandatory', () => {
             const field = {
@@ -1197,7 +1311,7 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe('aggregators', () => {
+    describe('function aggregators', () => {
         const aggregatorsIds = ['SUM', 'COUNT', 'COUNT_UNIQUE', 'UNIQUE_VALUES', 'AVG', 'MIN', 'MAX'];
 
         it('Count and names', () => {
@@ -2326,4 +2440,1201 @@ describe('highcharts_renderer', () => {
             });
         });
     });
+
+    describe('function getChartAxisLabel', () => {
+        it('should return default value', () => {
+            expect(highchartsRenderer.getChartAxisLabel('invalidType')).toBe('Axis (Category)')
+        });
+
+        it('should return chart type axisName', () => {
+            expect(highchartsRenderer.getChartAxisLabel(highchartsRenderer.CHART_TYPES.COLUMN_CHART)).toBe('X - Axis')
+        });
+    });
+
+    describe('function getChartLegendLabel', () => {
+        it('should return default value', () => {
+            expect(highchartsRenderer.getChartLegendLabel('invalidType')).toBe('Legend (Series)')
+        });
+
+        it('should return chart type legendName ', () => {
+            expect(highchartsRenderer.getChartLegendLabel(highchartsRenderer.CHART_TYPES.COLUMN_CHART)).toBe('Data series')
+        });
+    });
+
+    describe('Function getFilterLabel', () => {
+       describe('Should present template name', () => {
+           let fieldFilter;
+           let showTemplateName;
+
+           beforeEach(() => {
+               fieldFilter = {
+                   name: 'RH_DIM_test',
+                   datetypevalues: { datetype: 'range' }
+               };
+               showTemplateName = false;
+           });
+
+           it('should return fieldFilter.new_name without "RH_DIM_" if it exists', () => {
+               fieldFilter.new_name = 'RH_DIM_test_new_name';
+               const result = highchartsRenderer.getFilterLabel(fieldFilter, showTemplateName);
+               expect(result).toEqual({
+                   label: 'test_new_name (All)',
+                   tooltip: 'test_new_name (All)'
+               });
+           });
+
+           it('should return highchartsRenderer.getFieldName(fieldFilter.name) without "RH_DIM_" if fieldFilter.new_name is falsy', () => {
+               spyOn(highchartsRenderer, 'getFieldName').and.returnValue('RH_DIM_test_fieldName');
+               const result = highchartsRenderer.getFilterLabel(fieldFilter, showTemplateName);
+               expect(highchartsRenderer.getFieldName).toHaveBeenCalledWith('RH_DIM_test');
+               expect(result).toEqual({
+                   label: 'test_fieldName (All)',
+                   tooltip: 'test_fieldName (All)'
+               });
+           });
+
+           it('should append template_name to displayname if showTemplateName is true and fieldFilter.template_name is truthy', () => {
+               fieldFilter.new_name = null;
+               fieldFilter.template_name = 'templateName';
+               showTemplateName = true;
+               const result = highchartsRenderer.getFilterLabel(fieldFilter, showTemplateName);
+               expect(result).toEqual({
+                   label: 'templateName - test (range)',
+                   tooltip: 'templateName - test (range)'
+               });
+           });
+
+           it('should append template_name to displayname if showTemplateName is true and fieldFilter.template_name is truthy', () => {
+               fieldFilter.new_name = null;
+               fieldFilter.template_name = 'templateName';
+               showTemplateName = true;
+               const result = highchartsRenderer.getFilterLabel(fieldFilter, showTemplateName);
+               expect(result).toEqual({
+                   label: 'templateName - test (range)',
+                   tooltip: 'templateName - test (range)'
+               });
+           });
+
+           it('should return label and tooltip with datetypevalues.datetype if datetypevalues is truthy and datetype is "range" or "frame"', () => {
+               fieldFilter.new_name = null;
+               fieldFilter.template_name = 'templateName';
+               fieldFilter.datetypevalues.datetype = 'frame';
+               const result = highchartsRenderer.getFilterLabel(fieldFilter, showTemplateName);
+               expect(result).toEqual({
+                   label: 'test (frame)',
+                   tooltip: 'test (frame)'
+               });
+           });
+       });
+
+       describe('Should present includes/excludes names', () => {
+           let fieldFilter;
+
+           beforeEach(() => {
+               fieldFilter = {
+                   name: 'test',
+                   includes: null,
+                   excludes: null,
+                   type: 'Text',
+               };
+           });
+
+           it('Should return "none" label when excludes empty', () => {
+               fieldFilter.includes = [];
+               const res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (none)');
+               expect(res.tooltip).toEqual('test (none)');
+           });
+
+           it('Should return "All" label when excludes empty', () => {
+               fieldFilter.excludes = [];
+               const res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (All)');
+               expect(res.tooltip).toEqual('test (All)');
+           });
+
+           it('Should return "many" label when includes/excludes has more than MAX_SELECTED_ITEMS_IN_LABEL items', () => {
+               fieldFilter.includes = new Array(highchartsRenderer.MAX_SELECTED_ITEMS_IN_LABEL).fill('val');
+               let res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (many)');
+               expect(res.tooltip).toEqual('test (' + fieldFilter.includes.join(', ') + ')');
+
+               fieldFilter.excludes = fieldFilter.includes;
+               delete fieldFilter.includes;
+               res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (Exclusions many)');
+               expect(res.tooltip).toEqual('test (Exclusions: ' + fieldFilter.excludes.join(', ') + ')');
+           });
+
+           it('Should return "many" in label when includes has label length more than MAX_SELECTED_ITEMS_CHARECHTERS_IN_LABEL', () => {
+               fieldFilter.includes = ['[null]', 'long long long value 2', 'long long long value 3'];
+               let res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (many)');
+               expect(res.tooltip).toEqual('test (' + fieldFilter.includes.join(',') + ')');
+           });
+
+           it('Should return "many" in label when excludes has label length more than MAX_SELECTED_ITEMS_CHARECHTERS_IN_LABEL', () => {
+               fieldFilter.excludes = ['[null]', 'long long long value 2', 'long long long value 3'];
+               let res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (Exclusions: many)');
+               expect(res.tooltip).toEqual('test (Exclusions: ' + fieldFilter.excludes.join(',') + ')');
+           });
+
+           it('Should exclude "[null]" from includes if allow_nulls enabled', () => {
+               fieldFilter.allow_nulls = true;
+               fieldFilter.includes = ['value 1', '[null]'];
+               let res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (value 1)');
+               expect(res.tooltip).toEqual('test (' + fieldFilter.includes[0] + ')');
+           });
+
+           it('Should exclude "[null]" from excludes if allow_nulls enabled', () => {
+               fieldFilter.allow_nulls = true;
+               fieldFilter.excludes = ['value 1', '[null]'];
+               let res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (Exclusions: value 1)');
+               expect(res.tooltip).toEqual('test (Exclusions: ' + fieldFilter.excludes[0] + ')');
+           });
+
+           it('Should present formatted dates in includes. Get formatted value from invertValueFormatMap object if exist ', () => {
+               fieldFilter.includes = [1682063884, 1682060884, 1682013884];
+               fieldFilter.type = 'Date';
+               fieldFilter.valueFormatMap = {
+                   'April 21, 2023': 1682063884
+               };
+               let res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (April 21, 2023,04/21/2023,04/20/2023)');
+               expect(res.tooltip).toEqual('test (April 21, 2023,04/21/2023,04/20/2023)');
+           });
+
+           it('Should present formatted dates in excludes. Get formatted value from invertValueFormatMap object if exist ', () => {
+               fieldFilter.excludes = [1682063884, 1682060884];
+               fieldFilter.type = 'Date';
+               fieldFilter.valueFormatMap = {
+                   'April 21, 2023': 1682063884
+               };
+               let res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (Exclusions: April 21, 2023,04/21/2023)');
+               expect(res.tooltip).toEqual('test (Exclusions: April 21, 2023,04/21/2023)');
+           });
+       });
+
+       describe('Should present date range or frame selection', () => {
+           let fieldFilter;
+
+           beforeEach(() => {
+               fieldFilter = {
+                   name: 'test',
+                   includes: null,
+                   excludes: null,
+                   type: 'Date',
+               };
+           });
+
+           it('Should return "range" label when datetype is range', () => {
+               fieldFilter.datetypevalues = {
+                   datetype: 'range',
+                   val: {
+                       fromdate: 1682060884,
+                       todate: 1682063884,
+                   }
+               };
+               const res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (4/21/2023-4/21/2023)');
+               expect(res.tooltip).toEqual('test (4/21/2023-4/21/2023)');
+           });
+
+           it('Should return "frame" label when datetype is frame', () => {
+               fieldFilter.datetypevalues = {
+                   datetype: 'frame',
+                   val: {
+                       timeframe: 'xday'
+                   }
+               };
+               const res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (xday)');
+               expect(res.tooltip).toEqual('test (xday)');
+           });
+
+           it('Should return "All" label when datetype is not selected', () => {
+               fieldFilter.datetypevalues = {};
+               const res = highchartsRenderer.getFilterLabel(fieldFilter, false);
+               expect(res.label).toEqual('test (All)');
+               expect(res.tooltip).toEqual('test (All)');
+           });
+       });
+
+       describe('Should present advanced filter selection', () => {
+           it('Should return "Advanced" label when advanced type in values', () => {
+               const res = highchartsRenderer.getFilterLabel({ name: 'test', values: { type: 'advanced'} }, false);
+               expect(res.label).toEqual('test (Advanced)');
+               expect(res.tooltip).toEqual('test (Advanced)');
+           });
+
+           it('Should return "Advanced" label when advanced type in datetypevalues', () => {
+               const res = highchartsRenderer.getFilterLabel({ name: 'test', datetypevalues: { type: 'advanced'} }, false);
+               expect(res.label).toEqual('test (Advanced)');
+               expect(res.tooltip).toEqual('test (Advanced)');
+           });
+       });
+
+       describe('Should present All if nothing selected', () => {
+           it('Should return "All" label when nothing selected', () => {
+               const res = highchartsRenderer.getFilterLabel({ name: 'test'}, false);
+               expect(res.label).toEqual('test (All)');
+               expect(res.tooltip).toEqual('test (All)');
+           });
+       });
+    });
+
+    describe('function getRelevantFilters', () => {
+        it('should return an empty array if given an empty array', () => {
+            const filters = highchartsRenderer.getRelevantFilters([]);
+            expect(filters).toEqual([]);
+        });
+
+        it('should filter out elements that do not have includes, excludes, or datetypevalues properties', () => {
+            const filters = [
+                {fields: ['field1'], otherProperty: 'value'},
+                {fields: ['field2'], includes: [1, 2, 3]},
+                {fields: ['field3'], excludes: ['abc']},
+                {fields: ['field4'], datetypevalues: {datetype: 'date', start: '2022-01-01', end: '2022-01-31'}}
+            ];
+            const relevantFilters = highchartsRenderer.getRelevantFilters(filters);
+            expect(relevantFilters.length).toEqual(3);
+            expect(relevantFilters).toContainEqual({
+                fields: ['field2'],
+                values: [1, 2, 3],
+                is_excluded: false,
+                allow_nulls: false,
+                inject_only: false
+            });
+            expect(relevantFilters).toContainEqual({
+                fields: ['field3'],
+                values: ['abc'],
+                is_excluded: true,
+                allow_nulls: false,
+                inject_only: false
+            });
+            expect(relevantFilters).toContainEqual({
+                fields: ['field4'],
+                values: {datetype: 'date', start: '2022-01-01', end: '2022-01-31'},
+                is_excluded: false,
+                allow_nulls: false,
+                inject_only: false
+            });
+        });
+
+        it('should handle empty includes and excludes properties by returning an empty values array', () => {
+            const filters = [
+                {fields: ['field1'], includes: []},
+                {fields: ['field2'], includes: [1, 2, 3], excludes: []},
+                {fields: ['field3'], excludes: ['abc']}
+            ];
+            const relevantFilters = highchartsRenderer.getRelevantFilters(filters);
+            expect(relevantFilters.length).toEqual(3);
+            expect(relevantFilters[0].values).toEqual([]);
+            expect(relevantFilters[1].values).toEqual([1, 2, 3]);
+            expect(relevantFilters[2].values).toEqual(['abc']);
+        });
+
+        it('should set is_excluded to true for elements that have an excludes property', () => {
+            const filters = [
+                {fields: ['field1'], includes: [1, 2, 3]},
+                {fields: ['field2'], excludes: ['abc']},
+                {fields: ['field3'], excludes: [null]}
+            ];
+            const relevantFilters = highchartsRenderer.getRelevantFilters(filters);
+            expect(relevantFilters.length).toEqual(3);
+            expect(relevantFilters[0].is_excluded).toBe(false);
+            expect(relevantFilters[1].is_excluded).toBe(true);
+            expect(relevantFilters[2].is_excluded).toBe(true);
+        });
+
+        it('should handle datetypevalues', () => {
+            const filtersList = [
+                {
+                    fields: ['date'],
+                    datetypevalues: {
+                        datetype: 'last_month',
+                        from: null,
+                        to: null
+                    }
+                }
+            ];
+
+            const expected = [
+                {
+                    fields: ['date'],
+                    values: {
+                        datetype: 'last_month',
+                        from: null,
+                        to: null
+                    },
+                    is_excluded: false,
+                    allow_nulls: false,
+                    inject_only: false
+                }
+            ];
+
+            expect(highchartsRenderer.getRelevantFilters(filtersList)).toEqual(expected);
+        });
+    });
+
+    describe('function parseOptionsToObject', () => {
+        it('should return an object when given an object', () => {
+            const obj = { key: 'value' };
+            const result = highchartsRenderer.parseOptionsToObject(obj);
+            expect(result).toEqual(obj);
+        });
+
+        it('should return an empty object when given empty string', () => {
+            let result = highchartsRenderer.parseOptionsToObject('');
+            expect(result).toEqual({});
+        });
+
+        it('should parse a JSON string into an object', () => {
+            const str = '{ "key": "value" }';
+            const result = highchartsRenderer.parseOptionsToObject(str);
+            expect(result).toEqual({ key: 'value' });
+        });
+
+        it('should remove line breaks from the JSON string before parsing', () => {
+            const str = '{\n "key": "value"\n}';
+            const result = highchartsRenderer.parseOptionsToObject(str);
+            expect(result).toEqual({ key: 'value' });
+        });
+
+        it('should throw an error if given an invalid JSON string', () => {
+            const str = '{ "key": "value" ';
+            expect(() => highchartsRenderer.parseOptionsToObject(str)).toThrow();
+        });
+    });
+
+    describe('function getDashboardOverrideValues', () => {
+        let dataModel;
+        let graph;
+        let localCurrentDashboard;
+
+        beforeEach(() => {
+            dataModel = {
+                current_dashboard: {
+                    fields_selectors: [
+                        {
+                            value: 'field1',
+                            fields_selector: {
+                                default_field: { id: 'field1', name: 'Field 1' },
+                                other_fields: [
+                                    { id: 'field1', name: 'Field 1' },
+                                    { id: 'field2', name: 'Field 2' },
+                                ]
+                            }
+                        },
+                        {
+                            value: 'field2',
+                            fields_selector: {
+                                default_field: { id: 'field2', name: 'Field 2' },
+                                other_fields: [
+                                    { id: 'field1', name: 'Field 1' },
+                                    { id: 'field2', name: 'Field 2' },
+                                ]
+                            }
+                        }
+                    ]
+                },
+                ebmedded_override_value_ids: []
+            };
+
+            graph = {
+                vals: [{ field: 'field1' }]
+            };
+
+            localCurrentDashboard = {
+                fields_selectors: [
+                    {
+                        value: 'field2',
+                        fields_selector: {
+                            default_field: { id: 'field1', name: 'Field 1' },
+                            other_fields: [
+                                { id: 'field1', name: 'Field 1' },
+                                { id: 'field2', name: 'Field 2' },
+                            ]
+                        }
+                    }
+                ]
+            };
+        });
+
+        it('should return empty array when no conditions met', () => {
+            expect(highchartsRenderer.getDashboardOverrideValues({}, {}, {})).toEqual([]);
+        });
+
+        it('should return array of value objects when ebmedded_override_value_ids exist', () => {
+            dataModel.ebmedded_override_value_ids = [1, 2, 3]
+            expect(highchartsRenderer.getDashboardOverrideValues(dataModel, {}, {})).toEqual([
+                { id: 1 },
+                { id: 2 },
+                { id: 3 }
+            ]);
+        });
+
+        it('should return empty array when local_current_dashboard undefined', () => {
+            expect(highchartsRenderer.getDashboardOverrideValues({}, graph, undefined)).toEqual([]);
+        });
+
+        it('should return empty array when graph undefined', () => {
+            expect(highchartsRenderer.getDashboardOverrideValues(dataModel, undefined, localCurrentDashboard)).toEqual([]);
+        });
+
+        it('should return empty array when graph vals empty', () => {
+            expect(highchartsRenderer.getDashboardOverrideValues(dataModel, { vals: [] }, localCurrentDashboard)).toEqual([]);
+        });
+
+        it('should return empty array when graph vals length > 1', () => {
+            expect(highchartsRenderer.getDashboardOverrideValues(dataModel, { vals: [{ field: 'field1' }, { field: 'field2' }] }, localCurrentDashboard)).toEqual([]);
+        });
+
+        it('should return empty array when no matching field selector', () => {
+            expect(highchartsRenderer.getDashboardOverrideValues(dataModel, { vals: [{ field: 'field3' }] }, localCurrentDashboard)).toEqual([]);
+        });
+
+        it('should return value object when selector value != graph val field', () => {
+            expect(highchartsRenderer.getDashboardOverrideValues(dataModel, graph, localCurrentDashboard)).toEqual([{ id: 'field2', name: 'Field 2' }]);
+        });
+    });
+
+    describe('function getDashboardFilters', () => {
+        let data_model;
+        let remove_filters_from_global;
+
+        beforeEach(() => {
+            data_model = {
+                current_dashboard: {
+                    filters: [
+                        {
+                            fields: [{id: '1', name: 'Field 1'}],
+                            includes: ['value 1']
+                        },
+                        {
+                            fields: [{id: '2', name: 'Field 2'}],
+                            includes: ['value 2']
+                        }
+                    ]
+                },
+                ebmedded_filters: []
+            };
+            remove_filters_from_global = [{id: '2', name: 'Field 2'}];
+        });
+
+        it('should return an empty array when no relevant filters found', () => {
+            const local_current_dashboard = {
+                fields_selectors: [{value: '1', fields_selector: {default_field: {id: '1'}}}]
+            };
+            const result = highchartsRenderer.getDashboardFilters({}, [], local_current_dashboard);
+            expect(result).toEqual([]);
+        });
+
+        it('should return an array of relevant filters from the current dashboard', () => {
+            const result = highchartsRenderer.getDashboardFilters(data_model, [], data_model.current_dashboard);
+            expect(result.length).toEqual(2);
+        });
+
+        it('should return an array of relevant filters from the current dashboard and embedded filters', () => {
+            data_model.ebmedded_filters = [{
+                fields: [{id: '3', name: 'Field 3'}],
+                includes: ['value 3']
+            }];
+            const result = highchartsRenderer.getDashboardFilters(data_model, [], data_model.current_dashboard);
+            expect(result.length).toEqual(3);
+        });
+
+        it('should remove specified fields from the returned filters array', () => {
+            const result = highchartsRenderer.getDashboardFilters(data_model, remove_filters_from_global, data_model.current_dashboard);
+            expect(result.length).toEqual(1);
+        });
+
+        it('should add "[null]" to values array for filters with "allow_nulls" flag', () => {
+            const currentDashboardWithNull = {
+                filters: [
+                    {
+                        fields: [{ id: 'field1', name: 'Field 1' }],
+                        includes: ['value1', 'value2'],
+                        allow_nulls: false,
+                    },
+                ],
+            };
+            const dataModelWithNull = { current_dashboard: currentDashboardWithNull };
+            const result = highchartsRenderer.getDashboardFilters(dataModelWithNull);
+            expect(result[0].values).toEqual(['value1', 'value2']);
+        });
+
+        it('should not add "[null]" to values array if it is already present', () => {
+            const currentDashboardWithNull = {
+                filters: [
+                    {
+                        fields: [{ id: 'field1', name: 'Field 1' }],
+                        includes: ['value1'],
+                        allow_nulls: true,
+                    },
+                ],
+            };
+            const dataModelWithNull = { current_dashboard: currentDashboardWithNull };
+            const result = highchartsRenderer.getDashboardFilters(dataModelWithNull);
+            expect(result[0].values).toEqual(['value1', '[null]']);
+        });
+    });
+
+    describe('function getPresentationTagType', () => {
+        it('should return "date_tags" if local_current_dashboard has date tags', () => {
+            const data_model = {
+                current_dashboard: {
+                    date_tags: [{ id: 1, name: 'Date Tag 1' }]
+                }
+            };
+            const result = highchartsRenderer.getPresentationTagType(data_model, data_model.current_dashboard);
+            expect(result).toBe('date_tags');
+        });
+
+        it('should return "plan_tags" if local_current_dashboard has plan tags', () => {
+            const data_model = {
+                current_dashboard: {
+                    plan_tags: [{ id: 1, name: 'Plan Tag 1' }]
+                }
+            };
+            const result = highchartsRenderer.getPresentationTagType(data_model, data_model.current_dashboard);
+            expect(result).toBe('plan_tags');
+        });
+
+        it('should return undefined if local_current_dashboard has no tags', () => {
+            const data_model = {
+                current_dashboard: {}
+            };
+            const result = highchartsRenderer.getPresentationTagType(data_model);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return "date_tags" if local_current_dashboard is undefined but data_model has date tags', () => {
+            const data_model = {
+                current_dashboard: {
+                    date_tags: [{ id: 1, name: 'Date Tag 1' }]
+                }
+            };
+            const result = highchartsRenderer.getPresentationTagType(data_model);
+            expect(result).toBe('date_tags');
+        });
+
+        it('should return "plan_tags" if local_current_dashboard is undefined but data_model has plan tags', () => {
+            const data_model = {
+                current_dashboard: {
+                    plan_tags: [{ id: 1, name: 'Plan Tag 1' }]
+                }
+            };
+            const result = highchartsRenderer.getPresentationTagType(data_model);
+            expect(result).toBe('plan_tags');
+        });
+    });
+
+    describe('function getPresentationDataTag', () => {
+        const data_model = { current_dashboard: { presentation_data_tag_object: { value: 'foo' } } };
+        const dataKeyTag = 'date_tags';
+
+        it('returns presentation_data_tag_object value if local_current_dashboard is undefined', () => {
+            const result = highchartsRenderer.getPresentationDataTag(data_model, undefined, dataKeyTag);
+            expect(result).toBe('foo');
+        });
+
+        it('returns presentation_data_tag_object value if local_current_dashboard has presentation_data_tag_object', () => {
+            const local_current_dashboard = { presentation_data_tag_object: { value: 'bar' } };
+            const result = highchartsRenderer.getPresentationDataTag(data_model, local_current_dashboard, dataKeyTag);
+            expect(result).toBe('bar');
+        });
+
+        it('returns value of highest dataKeyTag value in local_current_dashboard', () => {
+            const local_current_dashboard = {
+                date_tags: [
+                    { value: '2022-01-01' },
+                    { value: '2021-01-01' },
+                    { value: '2023-01-01' },
+                ],
+            };
+            const result = highchartsRenderer.getPresentationDataTag(data_model, local_current_dashboard, dataKeyTag);
+            expect(result).toBe('2023-01-01');
+        });
+
+        it('returns null if local_current_dashboard has no presentation_data_tag_object or dataKeyTag values', () => {
+            const local_current_dashboard = {};
+            const result = highchartsRenderer.getPresentationDataTag(data_model, local_current_dashboard, dataKeyTag);
+            expect(result).toBeNull();
+        });
+
+        it('returns null if local_current_dashboard has empty dataKeyTag array', () => {
+            const local_current_dashboard = { date_tags: [] };
+            const result = highchartsRenderer.getPresentationDataTag(data_model, local_current_dashboard, dataKeyTag);
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('function getDashboardApplyScenarios', () => {
+        let data_model;
+        let graph;
+
+        beforeEach(() => {
+            graph = { vals: [{ field: 'field1' }] };
+            data_model = {
+                current_dashboard: {
+                    scenario_models: [
+                        {
+                            value: 1,
+                            scenario_model: { source_fields: ['field1'], scenarios: [{ id: 1 }, { id: 2 }] },
+                        },
+                        {
+                            value: 2,
+                            scenario_model: { source_fields: ['field2'], scenarios: [{ id: 3 }, { id: 4 }] },
+                        },
+                    ],
+                },
+                ebmedded_apply_scenario_ids: [],
+            };
+        });
+
+        it('returns ebmedded_apply_scenario_ids if data_model has it', () => {
+            data_model.ebmedded_apply_scenario_ids = [5, 6];
+            const local_current_dashboard = { foo: 'bar' };
+            const result = highchartsRenderer.getDashboardApplyScenarios(data_model, graph, local_current_dashboard);
+            expect(result).toEqual([5, 6]);
+        });
+
+        it('returns empty array if scenario_models in local_current_dashboard are not provided', () => {
+            const result = highchartsRenderer.getDashboardApplyScenarios(data_model, {vals: [null]}, {});
+            expect(result).toEqual([]);
+        });
+
+        it('returns empty array if graph has no vals', () => {
+            const result = highchartsRenderer.getDashboardApplyScenarios(data_model, {});
+            expect(result).toEqual([]);
+        });
+
+        it('returns empty array if graph has more than one val', () => {
+            const graph = { vals: [{ field: 'field1' }, { field: 'field2' }] };
+            const result = highchartsRenderer.getDashboardApplyScenarios(data_model, graph, {});
+            expect(result).toEqual([]);
+        });
+
+        it('returns array of selected scenario ids', () => {
+            const result = highchartsRenderer.getDashboardApplyScenarios(data_model, graph, data_model.current_dashboard);
+            expect(result).toEqual([1]);
+        });
+
+        it('returns empty array if no matching scenario is found', () => {
+            const graph = { vals: [{ field: 'field3' }] };
+            const result = highchartsRenderer.getDashboardApplyScenarios(data_model, graph, data_model.current_dashboard);
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('function isDate', () => {
+        it('returns true for valid date string', () => {
+            expect(highchartsRenderer.isDate('2022-01-01')).toBe(true);
+        });
+
+        it('returns false for invalid date string', () => {
+            expect(highchartsRenderer.isDate('not a date')).toBe(false);
+        });
+
+        it('returns false for undefined input', () => {
+            expect(highchartsRenderer.isDate(undefined)).toBe(false);
+        });
+
+        it('returns false for empty string input', () => {
+            expect(highchartsRenderer.isDate('')).toBe(false);
+        });
+    });
+
+    describe('function isDateFormat', () => {
+        it('returns true for valid date string and format', () => {
+            expect(highchartsRenderer.isDateFormat('2022-01-01', 'YYYY-MM-DD')).toBe(true);
+        });
+
+        it('returns false for invalid date string', () => {
+            expect(highchartsRenderer.isDateFormat('not a date', 'YYYY-MM-DD')).toBe(false);
+        });
+
+        it('returns false for null input', () => {
+            expect(highchartsRenderer.isDateFormat(null, 'YYYY-MM-DD')).toBe(false);
+        });
+
+        it('returns false for undefined input', () => {
+            expect(highchartsRenderer.isDateFormat(undefined, 'YYYY-MM-DD')).toBe(false);
+        });
+
+        it('returns false for non-string input', () => {
+            expect(highchartsRenderer.isDateFormat(123, 'YYYY-MM-DD')).toBe(false);
+        });
+
+        it('returns false for empty string input', () => {
+            expect(highchartsRenderer.isDateFormat('', 'YYYY-MM-DD')).toBe(false);
+        });
+
+        it('returns false for invalid format', () => {
+            expect(highchartsRenderer.isDateFormat('2022-01-01', 'invalid format')).toBe(false);
+        });
+    });
+
+    describe('function containsIgnoreCase', () => {
+        it('should return true when str contains it, ignoring case', () => {
+            const str = 'The quick brown fox jumps over the lazy dog';
+            const it = 'brown';
+            expect(highchartsRenderer.containsIgnoreCase(str, it)).toBe(true);
+        });
+
+        it('should return true when str contains it, with different case', () => {
+            const str = 'The quick brown fox jumps over the lazy dog';
+            const it = 'BROWN';
+            expect(highchartsRenderer.containsIgnoreCase(str, it)).toBe(true);
+        });
+
+        it('should return false when str does not contain it, ignoring case', () => {
+            const str = 'The quick brown fox jumps over the lazy dog';
+            const it = 'cat';
+            expect(highchartsRenderer.containsIgnoreCase(str, it)).toBe(false);
+        });
+
+        it('should return false when str is empty', () => {
+            const str = '';
+            const it = 'dog';
+            expect(highchartsRenderer.containsIgnoreCase(str, it)).toBe(false);
+        });
+    });
+
+    describe('function generateTableFormula', () => {
+        it('pivotUtilities.getPivotTableFormula should be called', () => {
+            spyOn($.pivotUtilities, 'getPivotTableFormula').and.callFake(() => null);
+            highchartsRenderer.generateTableFormula(1,2,3,4,5,6, 7);
+            expect($.pivotUtilities.getPivotTableFormula).lastCalledWith(1, 2, 3, 4, 5, 6, 7);
+        });
+    });
+
+    describe('function updateSelectedOverrideValues', () => {
+        const widget = {
+            vals: [{ name: 'selected_name' }]
+        };
+
+        const overrideValues = [{ name: 'override_name' }];
+
+        it('should update selected values in res object', () => {
+            const res = [
+                { override_name: 'value1', selected_name: 'valueA' },
+                { override_name: 'value2', selected_name: 'valueB' }
+            ];
+            const expectedRes = [
+                { override_name: 'value1', selected_name: 'value1' },
+                { override_name: 'value2', selected_name: 'value2' }
+            ];
+            expect(highchartsRenderer.updateSelectedOverrideValues(widget, overrideValues, res)).toEqual(expectedRes);
+        });
+
+        it('should not update res object if override_values array is empty', () => {
+            const res = [
+                { override_name: 'value1', selected_name: 'valueA' },
+                { override_name: 'value2', selected_name: 'valueB' }
+            ];
+            expect(highchartsRenderer.updateSelectedOverrideValues(widget, [], res)).toEqual(res);
+        });
+
+        it('should not update res object if name_to_find is no_name_for_selected', () => {
+            const res = [
+                { override_name: 'value1', selected_name: 'valueA' },
+                { override_name: 'value2', selected_name: 'valueB' }
+            ];
+            const overrideValues = [{ name: 'no_name_for_selected' }];
+            expect(highchartsRenderer.updateSelectedOverrideValues(widget, overrideValues, res)).toEqual(res);
+        });
+
+        it('should not update res object if name_to_set is null', () => {
+            const widget = { vals: [] };
+            const res = [
+                { override_name: 'value1', selected_name: 'valueA' },
+                { override_name: 'value2', selected_name: 'valueB' }
+            ];
+            expect(highchartsRenderer.updateSelectedOverrideValues(widget, overrideValues, res)).toEqual(res);
+        });
+    });
+
+    describe('function convertUniqueDateValues', () => {
+        const widget = {
+            template_id: 'template1',
+            vals: [
+                {field: 'field1', aggregator: 'UNIQUE_VALUES'},
+                {field: 'field2', aggregator: 'COUNT'}
+            ]
+        };
+
+        const templates = [
+            {id: 'template1', fields: [{id: 'field1', name: 'date_field', type: 'Date'}]},
+            {id: 'template2', fields: [{id: 'field3', name: 'string_field', type: 'String'}]}
+        ];
+
+        it('should convert unique date values in res object', () => {
+            const res = [
+                {date_field: [1640995200, 1641081600], string_field: 'value1'},
+                {date_field: [1641168000], string_field: 'value2'}
+            ];
+            const expectedRes = [
+                {date_field: ['01/01/2022', '01/02/2022'], string_field: 'value1'},
+                {date_field: ['01/03/2022'], string_field: 'value2'}
+            ];
+            expect(highchartsRenderer.convertUniqueDateValues(widget, templates, res)).toEqual(expectedRes);
+        });
+
+        it('should not convert date values if fields_to_convert is empty', () => {
+            const widget = {
+                template_id: 'template2',
+                vals: [
+                    {field: 'field1', aggregator: 'SUM'},
+                    {field: 'field2', aggregator: 'AVG'}
+                ]
+            };
+            const res = [
+                {date_field: ['2022-01-01', '2022-01-02'], string_field: 'value1'},
+                {date_field: ['2022-01-03'], string_field: 'value2'}
+            ];
+            expect(highchartsRenderer.convertUniqueDateValues(widget, templates, res)).toEqual(res);
+        });
+
+        it('should not convert date values if res is empty', () => {
+            const res = [];
+            expect(highchartsRenderer.convertUniqueDateValues(widget, templates, res)).toEqual(res);
+        });
+
+        it('should not convert date values if widget is null', () => {
+            const res = [
+                {date_field: ['2022-01-01', '2022-01-02'], string_field: 'value1'},
+                {date_field: ['2022-01-03'], string_field: 'value2'}
+            ];
+            expect(highchartsRenderer.convertUniqueDateValues(null, templates, res)).toEqual(res);
+        });
+
+        it('should not convert date values if widget.vals is null', () => {
+            const widget = {template_id: 'template1'};
+            const res = [
+                {date_field: ['2022-01-01', '2022-01-02'], string_field: 'value1'},
+                {date_field: ['2022-01-03'], string_field: 'value2'}
+            ];
+            expect(highchartsRenderer.convertUniqueDateValues(widget, templates, res)).toEqual(res);
+        });
+    });
+
+    describe('function setNewFieldNames', () => {
+        beforeEach(() => {
+            highchartsRenderer.useTotalsCalculation = false;
+        });
+
+        it('should return the input if useTotalsCalculation is true', () => {
+            const res = [{ DR_Values: 'value1' }, { DR_Values: 'value2' }];
+            highchartsRenderer.useTotalsCalculation = true;
+            const result = highchartsRenderer.setNewFieldNames(res);
+
+            expect(result).toEqual(res);
+        });
+
+        it('should update DR_Values field names', () => {
+            const res = [{ DR_Values: 'DR_Values' }, { DR_Values: 'value2' }];
+            const expected = [{ DR_Values: 'Values' }, { DR_Values: 'value2' }];
+            const result = highchartsRenderer.setNewFieldNames(res);
+
+            expect(result).toEqual(expected);
+        });
+
+        it('should handle empty input', () => {
+            const res = null;
+            const expected = null;
+            const result = highchartsRenderer.setNewFieldNames(res);
+
+            expect(result).toEqual(expected);
+        });
+
+        it('should handle empty DR_Values array in input', () => {
+            const res = [{}];
+            const expected = [{ DR_Values: undefined }];
+            const result = highchartsRenderer.setNewFieldNames(res);
+
+            expect(result).toEqual(expected);
+        });
+    });
+
+    describe('function getOptionsForLegends', () => {
+        const rowAttrsLength = 1;
+        let additionOptions;
+
+        beforeEach(() => {
+            highchartsRenderer.isMobile = false;
+            additionOptions = {
+                legends_position: {value: null},
+                hideChartHeader: false,
+                subtitle: {subtitle: null}
+            };
+        });
+
+        it('should return topPosition for mobile devices and legends_position is not set to none', () => {
+            highchartsRenderer.isMobile = true;
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, false);
+            expect(result.align).toEqual('left');
+            expect(result.verticalAlign).toEqual('top');
+            expect(result.layout).toEqual('horizontal');
+        });
+
+        it('should return topPosition when legends_position is not set and not line/pie chart', () => {
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, false);
+            expect(result.align).toEqual('left');
+            expect(result.verticalAlign).toEqual('top');
+            expect(result.layout).toEqual('horizontal');
+        });
+
+        it('should return leftPosition when legends_position is not set and line chart', () => {
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, true, false);
+            expect(result.align).toEqual('left');
+            expect(result.verticalAlign).toEqual('top');
+            expect(result.layout).toEqual('vertical');
+        });
+
+        it('should return rightPosition when legends_position is not set and pie chart', () => {
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, true);
+            expect(result.align).toEqual('right');
+            expect(result.verticalAlign).toEqual('top');
+            expect(result.layout).toEqual('vertical');
+        });
+
+        it('should return topPosition when legends_position is set to top', () => {
+            additionOptions.legends_position.value = 'top';
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, false);
+            expect(result.align).toEqual('left');
+            expect(result.verticalAlign).toEqual('top');
+            expect(result.layout).toEqual('horizontal');
+        });
+
+        it('should return bottomPosition when legends_position is set to bottom', () => {
+            additionOptions.legends_position.value = 'bottom';
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, false);
+            expect(result.maxHeight).toEqual(37);
+        });
+
+        it('should return leftPosition when legends_position is set to left', () => {
+            additionOptions.legends_position.value = 'left';
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, false);
+            expect(result.align).toEqual('left');
+            expect(result.verticalAlign).toEqual('top');
+            expect(result.layout).toEqual('vertical');
+        });
+
+        it('should return rightPosition when legends_position is set to right', () => {
+            additionOptions.legends_position.value = 'right';
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, false);
+            expect(result.align).toEqual('right');
+            expect(result.verticalAlign).toEqual('top');
+            expect(result.layout).toEqual('vertical');
+        });
+
+        it('should return disabled state when legends_position is set to none', () => {
+            additionOptions.legends_position.value = 'none';
+            const result = highchartsRenderer.getOptionsForLegends(additionOptions, rowAttrsLength, false, false);
+            expect(result.enabled).toEqual(false);
+        });
+    });
+
+    describe('function setYAxisMinMax', () => {
+        let yAxis;
+
+        beforeEach(() => {
+            yAxis = { min: null, max: null };
+        });
+
+        it('should set the minimum and maximum values of the yAxis if the axisYOptions is defined and has valid values', () => {
+            const axisYOptions = { min: '10', max: '20' };
+            highchartsRenderer.setYAxisMinMax(yAxis, axisYOptions);
+            expect(yAxis.min).toEqual(10);
+            expect(yAxis.max).toEqual(20);
+        });
+
+        it('should set the minimum value of the yAxis to null if the axisYOptions has an invalid minimum value', () => {
+            const axisYOptions = { min: 'invalid', max: '20' };
+            highchartsRenderer.setYAxisMinMax(yAxis, axisYOptions);
+            expect(yAxis.min).toBeNull();
+            expect(yAxis.max).toEqual(20);
+        });
+
+        it('should set the maximum value of the yAxis to null if the axisYOptions has an invalid maximum value', () => {
+            const axisYOptions = { min: '10', max: 'invalid' };
+            highchartsRenderer.setYAxisMinMax(yAxis, axisYOptions);
+            expect(yAxis.min).toEqual(10);
+            expect(yAxis.max).toBeNull();
+        });
+
+        it('should set the minimum and maximum values of the yAxis to null if the axisYOptions is not defined', () => {
+            highchartsRenderer.setYAxisMinMax(yAxis);
+            expect(yAxis.min).toBeNull();
+            expect(yAxis.max).toBeNull();
+        });
+    });
+
+    describe('function getDateFieldFormat', () => {
+        let widget;
+        let dateField;
+
+        beforeEach(() => {
+            widget = {
+                options: {
+                    date_aggregation_configs: [
+                        {
+                            field_id: 1,
+                            aggregate_by: 'quarter',
+                            is_formatting_by_aggregation_method: true,
+                        }
+                    ],
+                },
+            };
+
+            dateField = {
+                id: 1,
+                format: '%Y-%m-%d',
+            };
+        });
+
+        it('returns format as is when there is no aggregation config', () => {
+            widget.options.date_aggregation_configs = [];
+            const result = highchartsRenderer.getDateFieldFormat(widget, dateField);
+            expect(result).toEqual('%Y-%m-%d');
+        });
+
+        it('returns format by time frame when there is an aggregation config', () => {
+            const result = highchartsRenderer.getDateFieldFormat(widget, dateField);
+            expect(result).toEqual('[Q]Q-YY');
+        });
+
+        it('returns format as is when there is an aggregation config but no time frame specified', () => {
+            widget.options.date_aggregation_configs[0].aggregate_by = null;
+            const result = highchartsRenderer.getDateFieldFormat(widget, dateField);
+            expect(result).toEqual('%Y-%m-%d');
+        });
+    });
+
+    describe('function getDateFormatByTimeframe', () => {
+        it('should return the correct date format for "month" timeframe', () => {
+            const result = highchartsRenderer.getDateFormatByTimeframe('month', 'YYYY-MM-DD');
+            expect(result).toBe('MMM-YY');
+        });
+
+        it('should return the correct date format for "year" timeframe', () => {
+            const result = highchartsRenderer.getDateFormatByTimeframe('year', 'YYYY-MM-DD');
+            expect(result).toBe('YYYY');
+        });
+
+        it('should return the correct date format for "quarter" timeframe', () => {
+            const result = highchartsRenderer.getDateFormatByTimeframe('quarter', 'YYYY-MM-DD');
+            expect(result).toBe('[Q]Q-YY');
+        });
+
+        it('should return the default date format for unrecognized timeframe', () => {
+            expect(highchartsRenderer.getDateFormatByTimeframe('day', 'YYYY-MM-DD')).toBe('YYYY-MM-DD');
+            expect(highchartsRenderer.getDateFormatByTimeframe('week', 'YYYY-MM-DD')).toBe('YYYY-MM-DD');
+        });
+    });
+
+    describe('function getOthersName', () => {
+        it('returns the filtered out field name when it exists in options', () => {
+            const options = {
+                total_value_options: {
+                    filter_options: {
+                        filteredOutFieldName: 'Excluded'
+                    }
+                }
+            };
+            const othersName = highchartsRenderer.getOthersName(options);
+            expect(othersName).toBe('Excluded');
+        });
+
+        it('returns "Others" when the filtered out field name does not exist in options', () => {
+            const options = {};
+            const othersName = highchartsRenderer.getOthersName(options);
+            expect(othersName).toBe('Others');
+        });
+    });
+
+    describe('function transformRowsAndColsForBreakdown', () => {
+        let point;
+        let opts;
+        
+        beforeEach(() => {
+            point = {
+                options: {},
+                colKeys: ["Col1", "Col2", "Others"],
+            };
+
+            opts = {
+                total_value_options: {
+                    filter_options: {
+                        filteredOutFieldName: "Others",
+                    },
+                },
+            };
+        });
+
+        it("should replace Others with DR_Others in cols and return rows as cols when point is not total", () => {
+            const rows = ["Row1", "Row2"];
+            const cols = ["Col1", "Col2", "Others"];
+            const expectedResult = {
+                rows: cols,
+                cols: [point.colKeys[0]],
+            };
+
+            const result = highchartsRenderer.transformRowsAndColsForBreakdown(rows, cols, point, opts);
+            expect(result).toEqual(expectedResult);
+        });
+
+        it("should set rows to empty array when point is total", () => {
+            const rows = ["Row1", "Row2"];
+            const cols = ["Col1", "Col2", "Not_Others"];
+            point.options.isTotal = true;
+            const expectedResult = {
+                rows: [],
+                cols: cols,
+            };
+
+            const result = highchartsRenderer.transformRowsAndColsForBreakdown(rows, cols, point, opts);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+
+    describe('function getBreakdownXAxisLabelFormatter', () => {
+        it('returns correct formatter function', () => {
+            const chartSeries = [{
+                data: [
+                    { name: 'Label1', isTotal: true },
+                    { name: 'Label2', isTotal: false }
+                ]
+            }];
+            const formatter = highchartsRenderer.getBreakdownXAxisLabelFormatter(chartSeries);
+
+            const totalResult = formatter.apply({ value: 'Label1' });
+            expect(totalResult).toEqual('<span style=\"\">Label1</span>');
+
+            const normalResult = formatter.apply({ value: 'Label2' });
+            expect(normalResult).toEqual('<span style="font-weight: normal; color: #51566f;">Label2</span>');
+        });
+    });
+
+    describe('function getTrendSeriesName', () => {
+        it('returns expected name when name is present in the series object', () => {
+            const series = {
+                name: 'Sales'
+            };
+            const expectedName = 'Trend Line (Sales)';
+            expect(highchartsRenderer.getTrendSeriesName(series)).toBe(expectedName);
+        });
+
+        it('returns expected name when no name is present in the series object', () => {
+            const series = {};
+            const expectedName = 'Trend Line';
+            expect(highchartsRenderer.getTrendSeriesName(series)).toBe(expectedName);
+        });
+    });
 });