@datarailsshared/dr_renderer 1.2.295 → 1.2.296

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datarailsshared/dr_renderer",
-  "version": "1.2.295",
+  "version": "1.2.296",
   "description": "DataRails charts and tables renderer",
   "keywords": [
     "datarails",

package/src/highcharts_renderer.js

@@ -687,8 +687,8 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         stickOnContact: true,
         hideDelay: 1500,
         formatter: function () {
-            const rowKey = pivotData.rowAttrs.length ? _.get(this.point, 'series.name') || "" : "";
-            const colKey = _.get(this.point, 'name') || this.x.name[0] || "";
+            const rowKey = pivotData.rowAttrs.length ? lodash.get(this.point, 'series.name') || "" : "";
+            const colKey = lodash.get(this.point, 'name') || this.x.name[0] || "";
             const insight = pivotData.getInsight(colKey, rowKey) || {};
             setTimeout(() => {
                 var aggr = highchartsRenderer.defaultFormatterToTooltip(pivotData, opts);
@@ -1598,7 +1598,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             if (value.trend === 'total') {
                 keys = value.key;
             } else {
-                _.forEach(value.key, (item) => {
+                lodash.forEach(value.key, (item) => {
                     const findKeyByValue = lodash.find(
                         Object.keys(pivotData.dateValuesDictionary || {}),
                         key => pivotData.dateValuesDictionary[key] === item
@@ -3579,7 +3579,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         chartOptions.legend.useHTML = true;
         chartOptions.legend.labelFormatter = function() {
             const name = this.name;
-            const findTotal = _.find(this.options.data, {isTotal: true});
+            const findTotal = lodash.find(this.options.data, {isTotal: true});
             const color = lodash.get(findTotal, 'color') ? findTotal.color : this.color;
             return `<span style="margin: 5px; vertical-align: middle; display:inline-block; background-color: ${color};
                         width: 12px; height: 12px; border-radius: 50%"></span>
@@ -3699,7 +3699,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             chartOptions.legend.useHTML = true;
             chartOptions.legend.labelFormatter = function() {
                 const name = this.options.className ? 'Total': this.name;
-                const findTotal = _.find(this.options.data, {isTotal: true});
+                const findTotal = lodash.find(this.options.data, {isTotal: true});
                 const color = lodash.get(findTotal, 'color') ? findTotal.color : this.color;
                 return '<span style="margin: 5px; vertical-align: middle; display:inline-block; background-color: '+ color + '; width: 12px; height: 12px; border-radius: 50%"></span><span style="color: #000; display: inline-block; margin: 5px; vertical-align: middle;">' + name + '</span>';
             }
@@ -4936,7 +4936,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             }
 
             if (typeof (value) != 'number') {
-                const drAdditionalField = _.find($.pivotUtilities.additionalFieldsList, {key: value});
+                const drAdditionalField = lodash.find($.pivotUtilities.additionalFieldsList, {key: value});
                 if (drAdditionalField && drAdditionalField.key)
                     return drAdditionalField.key;
 
@@ -8045,8 +8045,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                   };
             }
         } else {
-            if (fieldFilter && fieldFilter.type && fieldFilter.type === 'Date'
-                && fieldFilter.datetypevalues && fieldFilter.datetypevalues) {
+            if (fieldFilter && fieldFilter.type && fieldFilter.type === 'Date' && fieldFilter.datetypevalues) {
                 if (fieldFilter.datetypevalues.datetype === "frame") {
                     displayname += ` (${fieldFilter.datetypevalues.val.timeframe})`;
                 } else if (fieldFilter.datetypevalues.datetype === "range") {
@@ -8058,7 +8057,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                     // range timestamps currently are set presupposing that user selects UTC dates,
                     // that is why for consistency we also should show in filters values which user selected
                     // and not local dates, that can differ
-                    _.forEach(Object.keys(dates), key => {
+                    lodash.forEach(Object.keys(dates), key => {
                         const dateConfiguration = dates[key];
                         const timestamp = dateConfiguration.timestamp;
                         if (timestamp) {
@@ -8124,7 +8123,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
     highchartsRenderer.getDashboardOverrideValues = function (data_model, graph, local_current_dashboard) {
         let overrideValues = [];
 
-        if (!local_current_dashboard == undefined) {
+        if (!local_current_dashboard) {
             local_current_dashboard = data_model.current_dashboard;
         }
 
@@ -8200,11 +8199,11 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             local_current_dashboard = data_model.current_dashboard;
         }
 
-        if (local_current_dashboard.date_tags.length > 0) {
+        if (local_current_dashboard.date_tags && local_current_dashboard.date_tags.length > 0) {
             return 'date_tags';
         }
 
-        if (local_current_dashboard.plan_tags.length > 0) {
+        if (local_current_dashboard.plan_tags && local_current_dashboard.plan_tags.length > 0) {
             return 'plan_tags';
         }
     };
@@ -8230,7 +8229,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
     };
 
     highchartsRenderer.getDashboardApplyScenarios = function (data_model, graph, local_current_dashboard) {
-        if (!local_current_dashboard == undefined) {
+        if (local_current_dashboard == undefined) {
             local_current_dashboard = data_model.current_dashboard;
         }
 
@@ -8256,7 +8255,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
     };
 
     highchartsRenderer.isDate = function (date) {
-        return ((new Date(date) !== "Invalid Date" && !isNaN(new Date(date))));
+        return new Date(date) !== "Invalid Date" && !isNaN(new Date(date));
     };
 
     highchartsRenderer.isDateFormat = function (datestr, format) {
@@ -8264,7 +8263,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
     };
 
     highchartsRenderer.containsIgnoreCase = function (str, it) {
-        return str.toLowerCase().indexOf(it) != -1;
+        return str.toLowerCase().indexOf(it.toLowerCase()) != -1;
     };
 
     highchartsRenderer.createDateTypeFromValue = function (fieldnametoFilter, format, colName) {
@@ -9100,7 +9099,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
 
     highchartsRenderer.getDateFieldFormat = function(widget, dateField) {
         const aggregationConfig = widget.options && widget.options.date_aggregation_configs
-            ? _.find(widget.options.date_aggregation_configs, { field_id: dateField.id })
+            ? lodash.find(widget.options.date_aggregation_configs, { field_id: dateField.id })
             : null;
 
         if (aggregationConfig && aggregationConfig.aggregate_by && aggregationConfig.is_formatting_by_aggregation_method) {
@@ -9174,7 +9173,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 rowData.splice(rowIndex, 1);
             } else {
                 const totalRow = {};
-                _.forEach(categoryFields, (field, fieldKey) => {
+                lodash.forEach(categoryFields, (field, fieldKey) => {
                     totalRow[field.name] = value.key[fieldKey];
                 });
                 totalRow[valueField.name] = sum;
@@ -9232,7 +9231,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         });
     }
 
-
     highchartsRenderer.getFiscalYearMonthModifier = function() {
         return lodash.get(document, 'ReportHippo.user.organization.fiscal_year_starts_from', 1) - 1;
     }

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";
@@ -1197,7 +1197,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 +2326,1202 @@ 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);
+        });
+    });
 });