@datarailsshared/dr_renderer 1.2.318-rocket → 1.2.321

package/tests/highcharts_renderer.test.js

@@ -483,6 +483,7 @@ describe('highcharts_renderer', () => {
         let opts;
 
         beforeEach(() => {
+            highchartsRenderer.enabledNewWidgetValueFormatting = false;
             funcContext = { y: '12345.678' };
             opts = {}
         });
@@ -1323,6 +1324,264 @@ describe('highcharts_renderer', () => {
         });
     });
 
+    describe("function updateBackwardCompatibleWidgetOptions", () => {
+        it("should delete chart 'hideLegends' option if exists and true", () => {
+            const options = {
+                chartOptions: {
+                    chart: {
+                        hideLegends: true
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
+            expect(options.chartOptions.legends_position.value).toBe('none');
+            expect(options.chartOptions.chart.hideLegends).toBe(undefined);
+        });
+
+        it("should move error_policy chart option to advanced chart option", () => {
+            const error_policy = 'test_policy';
+            const options = {
+                chartOptions: {
+                    error_policy: {
+                        error_policy: error_policy
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
+            expect(options.chartOptions.advanced.from_latest).toBe('');
+            expect(options.chartOptions.advanced.error_policy).toBe(error_policy);
+            expect(options.chartOptions.error_policy).toBe(undefined);
+            expect(options.chartOptions.from_version).toBe(undefined);
+        });
+
+        it("should move from_version chart option to advanced chart option", () => {
+            const from_version = 'from_version';
+            const options = {
+                chartOptions: {
+                    from_version: {
+                        value: from_version
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
+            expect(options.chartOptions.advanced.from_latest).toBe(from_version);
+            expect(options.chartOptions.advanced.error_policy).toBe('None');
+            expect(options.chartOptions.error_policy).toBe(undefined);
+            expect(options.chartOptions.from_version).toBe(undefined);
+        });
+
+        it("should remove chart label style option", () => {
+            const options = {
+                chartOptions: {
+                    label: {
+                        style: 'color: red;'
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
+            expect(options.chartOptions.label.style).toBe(undefined);
+        });
+
+        it("should remove chart label_pie style option", () => {
+            const options = {
+                chartOptions: {
+                    label_pie: {
+                        style: 'color: red;'
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'line-chart')
+            expect(options.chartOptions.label_pie.style).toBe(undefined);
+        });
+
+        it("update pie-chart label options if only_value", () => {
+            const options = {
+                chartOptions: {
+                    label: {
+                        only_value: true
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'pie-chart')
+            expect(options.chartOptions.label_pie).toEqual({
+                show_percentage_in_labels: false,
+                show_value_in_labels: true
+            });
+            expect(options.chartOptions.label).toBe(undefined);
+        });
+
+        it("update pie-chart label options if only_percentage", () => {
+            const options = {
+                chartOptions: {
+                    label: {
+                        only_percentage: true
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'pie-chart')
+            expect(options.chartOptions.label_pie).toEqual({
+                show_percentage_in_labels: true,
+                show_value_in_labels: false
+            });
+            expect(options.chartOptions.label).toBe(undefined);
+        });
+
+        it("update pie-chart label options if show", () => {
+            const options = {
+                chartOptions: {
+                    label: {
+                        show: true
+                    }
+                },
+                comboOptions: {}
+            };
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, 'pie-chart');
+            expect(options.chartOptions.label_pie).toEqual({
+                show: true,
+                show_percentage_in_labels: true,
+                show_value_in_labels: true
+            });
+            expect(options.chartOptions.label).toBe(undefined);
+        });
+
+        it("should do nothing if pie chart without 'only_percentage/only_value/show'", () => {
+            const options1 = {
+                chartOptions: { label: { } }, comboOptions: {}
+            };
+            const options2 = {
+                chartOptions: { }, comboOptions: {}
+            };
+
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options1, 'pie-chart');
+            expect(options1).toEqual({
+                chartOptions: { label_pie: {} }, comboOptions: {}
+            });
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options2, 'pie-chart');
+            expect(options2).toEqual({
+                chartOptions: { }, comboOptions: {}
+            });
+        });
+
+        it("should create comboOptions for different series types", () => {
+            const options = {
+                chartOptions: {
+                    delta_column: {
+                        field: 'series',
+                        name: 'TEST_test',
+                        same_yaxis: true,
+                        is_percentage: true,
+                    }
+                }
+            };
+
+            const seriesTypes = ['line', 'spline', 'area', 'areaspline', 'scatter', 'column', 'default'];
+            const seriesTypesMap = ['line-chart', 'line-chart-smooth', 'area-chart', 'area-chart-smooth', 'scatter-chart', 'column-chart', 'scatter-chart'];
+
+            seriesTypes.forEach((type, index) => {
+                const currentOptions = lodash.cloneDeep(options);
+                currentOptions.chartOptions.delta_column.chart = type;
+                highchartsRenderer.updateBackwardCompatibleWidgetOptions(currentOptions, null);
+                expect(currentOptions.comboOptions).toEqual({
+                    secondaryAxisSettings: {
+                        name: 'TESTtest',
+                        max: null,
+                        min: null,
+                        is_percentage: true
+                    },
+                    seriesOptions: [{
+                        series: 'TEST_test',
+                        secondaryAxis: false,
+                        chartType: seriesTypesMap[index]
+                    }]
+                });
+            });
+        });
+
+        it("should create comboOptions without series options if no delta_column field", () => {
+            const options = {};
+            highchartsRenderer.updateBackwardCompatibleWidgetOptions(options, null);
+            expect(options).toEqual({
+                comboOptions :{
+                    secondaryAxisSettings: {
+                        name: 'Secondary Axis',
+                        max: null,
+                        min: null,
+                        is_percentage: false,
+                    },
+                    seriesOptions: []
+                }
+            });
+        });
+    });
+
+    describe("function setMissingWidgetOptions", () => {
+        it("should return do nothing if there are no chartOptions", () => {
+            const options = { testProp: true };
+            highchartsRenderer.setMissingWidgetOptions(options, null)
+            expect(options).toEqual({ testProp: true });
+        });
+
+        it("should merge current chart options with default", () => {
+            spyOn(highchartsRenderer, 'getDefaultValueForChart').and.returnValue({
+                array: [1, 3, 5],
+                newProp: 'defaultNew',
+                existingProp: 'defaultExist',
+                obj: {
+                    newProp: 'defaultNew',
+                    existingProp: 'defaultExist',
+                },
+                newObj: {
+                    newProp: 'defaultNew',
+                }
+            });
+            const options = {
+                chartOptions: {
+                    array: [2, 5, 6],
+                    existingProp: 'exist',
+                    obj: {
+                        existingProp: 'exist',
+                    }
+                }
+            };
+            highchartsRenderer.setMissingWidgetOptions(options, 'line-chart')
+            expect(options.chartOptions).toEqual({
+                array: [2, 5, 6],
+                existingProp: "exist",
+                newObj: { newProp: "defaultNew" },
+                newProp: "defaultNew",
+                obj: {
+                    existingProp: "exist",
+                    newProp: "defaultNew"
+                }
+            });
+        });
+    });
+
+    describe('function getChartOptionsBySubType', () => {
+        it('returns null for rich_text subtype', () => {
+            const result = highchartsRenderer.getChartOptionsBySubType('rich_text');
+            expect(result).toBe(highchartsRenderer.richTextSubType);
+        });
+
+        it('returns chart options for existing subtype', () => {
+            const result = highchartsRenderer.getChartOptionsBySubType('line-chart');
+            expect(result.type).toEqual('line-chart');
+            expect(result.suboptions.length).toEqual(highchartsRenderer.chartsData[0].subtypes[0].suboptions.length);
+        });
+
+        it('returns null for non-existing subtype', () => {
+            const result = highchartsRenderer.getChartOptionsBySubType('nonExistingType');
+            expect(result).toBe(null);
+        });
+    });
+
     describe('function aggregators', () => {
         const aggregatorsIds = ['SUM', 'COUNT', 'COUNT_UNIQUE', 'UNIQUE_VALUES', 'AVG', 'MIN', 'MAX'];
 
@@ -1477,6 +1736,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -1523,6 +1783,21 @@ describe('highcharts_renderer', () => {
                         aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
                         expect(aggregatorObject.ignoreValue).toBe(true);
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.formats).toEqual(['\"$\"#,###.###']);
+                    });
                 });
 
                 describe('Value method', () => {
@@ -1573,6 +1848,22 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        widget_values_format = '\"$\"#,###.###';
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                    });
                 });
             });
 
@@ -1654,6 +1945,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -1700,6 +1992,21 @@ describe('highcharts_renderer', () => {
                         aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
                         expect(aggregatorObject.ignoreValue).toBe(true);
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.formats).toEqual(['\"$\"#,###.###']);
+                    });
                 });
 
                 describe('Value method', () => {
@@ -1750,6 +2057,22 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        widget_values_format = '\"$\"#,###.###';
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                    });
                 });
             });
 
@@ -1985,6 +2308,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -2033,6 +2357,21 @@ describe('highcharts_renderer', () => {
                         aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
                         expect(aggregatorObject.ignoreValue).toBe(true);
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.formats).toEqual(['\"$\"#,###.###']);
+                    });
                 });
 
                 describe('Value method', () => {
@@ -2092,6 +2431,22 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        widget_values_format = '\"$\"#,###.###';
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                    });
                 });
             });
 
@@ -2173,6 +2528,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -2219,6 +2575,21 @@ describe('highcharts_renderer', () => {
                         aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
                         expect(aggregatorObject.ignoreValue).toBe(true);
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.formats).toEqual(['\"$\"#,###.###']);
+                    });
                 });
 
                 describe('Value method', () => {
@@ -2270,6 +2641,22 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        widget_values_format = '\"$\"#,###.###';
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                    });
                 });
             });
 
@@ -2351,6 +2738,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -2397,6 +2785,21 @@ describe('highcharts_renderer', () => {
                         aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
                         expect(aggregatorObject.ignoreValue).toBe(true);
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.formats).toEqual(['\"$\"#,###.###']);
+                    });
                 });
 
                 describe('Value method', () => {
@@ -2448,11 +2851,411 @@ describe('highcharts_renderer', () => {
                         aggregatorObject = aggregator({}, ['Region average'], '');
                         expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
                     });
+
+                    it('if FF enabledNewWidgetValueFormatting is and some of secondaryAxis is true widget values format must be from seriesOptions and widget_value_format to equal first seriesOptions format', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = true;
+                        widget_values_format = '\"$\"#,###.###';
+                        const options = {
+                            comboOptions: {
+                                seriesOptions: [
+                                    {series: 'Profit', format: '\"$\"#,###.###' , secondaryAxis: true},
+                                ]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Profit'], '');
+                        aggregatorObject.push({ DR_Values: 'Profit', Profit: 123 });
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('$1,123.457');
+                    });
                 });
             });
         });
     });
 
+    describe('function getDefaultValueForChart', () => {
+        it('should return empty value for rich_text type', () => {
+            expect(highchartsRenderer.getDefaultValueForChart('rich_text', {})).toEqual({});
+        });
+
+        it('should return default value for line-chart type if existing options are empty', () => {
+            const res = highchartsRenderer.getDefaultValueForChart('line-chart', {});
+            expect(Object.keys(res).length).toEqual(highchartsRenderer.chartsData[0].subtypes[0].suboptions.length);
+        });
+    });
+
+    describe('function getCommonChartOptions', () => {
+        const TOOLTIP_DEFAULT_OPTIONS = {
+            borderColor: '#fff',
+            shadow: {
+                color: '#9199b4',
+                width: 10,
+                opacity: 0.05
+            },
+            style: {
+                fontSize: '12',
+                fontFamily: 'Poppins',
+                color: '#545a6b',
+            },
+            enabled: true,
+        };
+
+        it('should return empty object if additionalOptions is null or undefined', () => {
+            expect(highchartsRenderer.getCommonChartOptions(null)).toEqual({});
+            expect(highchartsRenderer.getCommonChartOptions(undefined)).toEqual({});
+        });
+
+        it('should return empty tooltip if additionalOptions has no tooltips', () => {
+            const additionalOptions = { };
+            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual({});
+        });
+
+        it('should return tooltip with default options if tooltips.show is not defined', () => {
+            const additionalOptions = { tooltips: {} };
+            const expected = { tooltip: TOOLTIP_DEFAULT_OPTIONS };
+            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual(expected);
+        });
+
+        it('should return tooltip with custom style options', () => {
+            const additionalOptions = {
+                tooltips: {
+                    show: true,
+                    font_size: 14,
+                    font_style: 'Arial',
+                    font_color: '#333',
+                }
+            };
+            const expected = {
+                tooltip: {
+                    borderColor: '#fff',
+                    shadow: {
+                        color: '#9199b4',
+                        width: 10,
+                        opacity: 0.05
+                    },
+                    style: {
+                        fontSize: 14,
+                        fontFamily: 'Arial',
+                        color: '#333',
+                    },
+                    enabled: true,
+                }
+            };
+            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual(expected);
+        });
+
+        it('should return tooltip with custom style options and show set to false', () => {
+            const additionalOptions = {
+                tooltips: {
+                    show: false,
+                    font_size: 14,
+                    font_style: 'Arial',
+                    font_color: '#333',
+                }
+            };
+            const expected = {
+                tooltip: {
+                    borderColor: '#fff',
+                    shadow: {
+                        color: '#9199b4',
+                        width: 10,
+                        opacity: 0.05
+                    },
+                    style: {
+                        fontSize: 14,
+                        fontFamily: 'Arial',
+                        color: '#333',
+                    },
+                    enabled: false,
+                }
+            };
+            expect(highchartsRenderer.getCommonChartOptions(additionalOptions)).toEqual(expected);
+        });
+    });
+    
+    describe('function getDataLabelsStyle', () => {
+        it('returns default style if additionalOptions is empty', () => {
+            const additionalOptions = {};
+            const defaultStyle = { color: '#333', fontWeight: 'bold' };
+            const expected = defaultStyle;
+            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
+            expect(actual).toEqual(expected);
+        });
+
+        it('returns default style if additionalOptions does not contain a label option key', () => {
+            const additionalOptions = { backgroundColor: '#fff' };
+            const defaultStyle = { color: '#333', fontWeight: 'bold' };
+            const expected = defaultStyle;
+            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
+            expect(actual).toEqual(expected);
+        });
+
+        it('returns style merged with defaultStyle if both exist', () => {
+            const additionalOptions = { label_1: { font_size: '16px' } };
+            const defaultStyle = { color: '#333', fontWeight: 'bold' };
+            const expected = { color: '#333', fontWeight: 'bold', fontSize: '16px' };
+            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
+            expect(actual).toEqual(expected);
+        });
+
+        it('returns style with font size and font family if they exist', () => {
+            const additionalOptions = { label_1: { font_size: '16px', font_style: 'Helvetica' } };
+            const defaultStyle = { color: '#333', fontWeight: 'bold' };
+            const expected = { color: '#333', fontWeight: 'bold', fontSize: '16px', fontFamily: 'Helvetica' };
+            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
+            expect(actual).toEqual(expected);
+        });
+
+        it('returns style only with font size and font family if defaultStyle has wrong format', () => {
+            const additionalOptions = { label_1: { font_size: '16px', font_style: 'Helvetica' } };
+            const defaultStyle = "{ color: '#333', fontWeight: 'bold' }";
+            const expected = { fontSize: '16px', fontFamily: 'Helvetica' };
+            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
+            expect(actual).toEqual(expected);
+        });
+
+        it('returns style only with font size and font family if defaultStyle is null', () => {
+            const additionalOptions = { label_1: { font_size: '16px', font_style: 'Helvetica' } };
+            const defaultStyle = null;
+            const expected = { fontSize: '16px', fontFamily: 'Helvetica' };
+            const actual = highchartsRenderer.getDataLabelsStyle(additionalOptions, defaultStyle);
+            expect(actual).toEqual(expected);
+        });
+    });
+
+    describe('function getDataLabelsOptions', () => {
+        const defaultDataLabels = {
+            color: "#151a41",
+            enabled: true,
+            style: {
+                fontFamily: "Poppins",
+                fontSize: "12px",
+                fontWeight: "bold"
+            }
+        };
+
+        it('should return chartOptions with default data label options if additionalOptions is not defined', () => {
+            const chartOptions = {
+                dataLabels: {
+                    enabled: true,
+                    style: {
+                        fontSize: '12px',
+                        fontWeight: 'bold',
+                    },
+                },
+            };
+            const result = highchartsRenderer.getDataLabelsOptions(undefined, chartOptions);
+            expect(result).toEqual(chartOptions);
+            expect(result.dataLabels).toEqual(defaultDataLabels);
+        });
+
+        it('should return chartOptions with merged data label options if additionalOptions does not contain a label key', () => {
+            const additionalOptions = {
+                option1: 'value1',
+                option2: 'value2',
+                option3: 'value3',
+            };
+            const chartOptions = {
+                dataLabels: {
+                    enabled: true,
+                    style: {
+                        fontSize: '13px',
+                        fontWeight: 'normal',
+                    },
+                },
+            };
+            const expected = {
+                dataLabels: {
+                    color: "#151a41",
+                    enabled: true,
+                    style: {
+                        fontFamily: "Poppins",
+                        fontSize: "13px",
+                        fontWeight: "normal"
+                    }
+                }
+            };
+            const result = highchartsRenderer.getDataLabelsOptions(additionalOptions, chartOptions);
+            expect(result).toEqual(expected);
+        });
+
+        it('should return chartOptions with merged data label options if additionalOptions contains a label key', () => {
+            const additionalOptions = {
+                label_option: {
+                    font_color: 'red',
+                },
+            };
+            const chartOptions = {
+                dataLabels: {
+                    enabled: true,
+                    style: {
+                        fontSize: '15px',
+                        fontWeight: 'bold',
+                    },
+                },
+            };
+            const expected = {
+                dataLabels: {
+                    color: "red",
+                    enabled: true,
+                    style: {
+                        fontFamily: "Poppins",
+                        fontSize: "15px",
+                        fontWeight: "bold"
+                    }
+                }
+            };
+            const result = highchartsRenderer.getDataLabelsOptions(additionalOptions, chartOptions);
+            expect(result).toEqual(expected);
+        });
+    });
+    
+    describe('function getLabelOptionKey', () => {
+        it('should return null if additionalOptions is not defined', () => {
+            const result = highchartsRenderer.getLabelOptionKey(undefined);
+            expect(result).toBeNull();
+        });
+
+        it('should return null if no label key is found in additionalOptions', () => {
+            const additionalOptions = {
+                option1: 'value1',
+                option2: 'value2',
+                option3: 'value3',
+            };
+            const result = highchartsRenderer.getLabelOptionKey(additionalOptions);
+            expect(result).toBeNull();
+        });
+
+        it('should return the label key if found in additionalOptions', () => {
+            const additionalOptions = {
+                option1: 'value1',
+                label_option: 'value2',
+                option3: 'value3',
+            };
+            const result = highchartsRenderer.getLabelOptionKey(additionalOptions);
+            expect(result).toBe('label_option');
+        });
+
+        it('should return the first label key if multiple label keys are found in additionalOptions', () => {
+            const additionalOptions = {
+                label_option1: 'value1',
+                option1: 'value2',
+                label_option2: 'value3',
+            };
+            const result = highchartsRenderer.getLabelOptionKey(additionalOptions);
+            expect(result).toBe('label_option1');
+        });
+    });
+    
+    describe('function getDefaultValueForSubOptions', () => {
+        const suboptions = {
+            option1: {
+                category_type: 'type1',
+                elements: [
+                    {
+                        value_name: 'value1',
+                        element_type: 'text',
+                        default_value: 'default1',
+                    },
+                    {
+                        value_name: 'value2',
+                        element_type: 'number',
+                        default_value: 42,
+                    },
+                    {
+                        value_name: 'value3',
+                        element_type: 'devider',
+                    },
+                ],
+            },
+            option2: {
+                category_type: 'type2',
+                elements: [
+                    {
+                        value_name: 'value1',
+                        element_type: 'text',
+                        default_value: 'default2',
+                    },
+                    {
+                        value_name: 'value2',
+                        element_type: 'number',
+                        default_value: 23,
+                    },
+                    {
+                        value_name: 'value3',
+                        element_type: 'devider',
+                    },
+                ],
+            },
+            option3: {
+                category_type: 'type3',
+                elements: [
+                    {
+                        value_name: 'value1',
+                        element_type: 'text',
+                        default_value: { val: 1 },
+                    }
+                ],
+            },
+        };
+        let tempSubOptions = null;
+
+        beforeAll(() => {
+            tempSubOptions = highchartsRenderer.suboptions;
+            highchartsRenderer.suboptions = suboptions;
+        });
+
+        afterAll(() => {
+            highchartsRenderer.suboptions = tempSubOptions;
+        });
+
+        it('should return an empty object if option type is not found', () => {
+            const type = 'invalid_type';
+            const existing_options = {};
+            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
+            expect(result).toEqual({});
+        });
+
+        it('should return default values for all elements in suboption', () => {
+            const type = 'type1';
+            const existing_options = {};
+            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
+            expect(result).toEqual({
+                value1: 'default1',
+                value2: 42,
+            });
+        });
+
+        it('should use existing options if available', () => {
+            const type = 'type1';
+            const existing_options = {
+                type1: {
+                    value1: 'existing1',
+                    value2: 99,
+                },
+            };
+            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
+            expect(result).toEqual({
+                value1: 'existing1',
+                value2: 99,
+            });
+        });
+
+        it('should ignore elements with type "devider"', () => {
+            const type = 'type1';
+            const existing_options = {};
+            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
+            expect(result).not.toHaveProperty('value3');
+        });
+
+        it('should clone default value if it is an object', () => {
+            const type = 'type3';
+            const existing_options = {};
+            const result = highchartsRenderer.getDefaultValueForSubOptions(type, existing_options);
+            expect(result.value1).toEqual(suboptions.option3.elements[0].default_value);
+            expect(result.value1).not.toBe(suboptions.option3.elements[0].default_value);
+        });
+    });
+    
     describe('function getChartAxisLabel', () => {
         it('should return default value', () => {
             expect(highchartsRenderer.getChartAxisLabel('invalidType')).toBe('Axis (Category)')
@@ -3649,4 +4452,144 @@ describe('highcharts_renderer', () => {
             expect(highchartsRenderer.getTrendSeriesName(series)).toBe(expectedName);
         });
     });
+
+    describe('function checkFormats', () => {
+        it('should correctly detect if any series is on secondary axis', () => {
+            const render_options = {
+                comboOptions: {
+                    seriesOptions: [
+                        { secondaryAxis: false },
+                        { secondaryAxis: true },
+                        { secondaryAxis: false },
+                    ],
+                },
+            };
+            const widget_values_format = '#,###';
+            const result = highchartsRenderer.checkFormats(render_options, widget_values_format);
+            expect(result.isSecondaryAxis).toBe(true);
+        });
+
+        it('should correctly detect if all series are on primary axis', () => {
+            const render_options = {
+                comboOptions: {
+                    seriesOptions: [
+                        { secondaryAxis: false },
+                        { secondaryAxis: false },
+                        { secondaryAxis: false },
+                    ],
+                },
+            };
+            const widget_values_format = '#,###';
+            const result = highchartsRenderer.checkFormats(render_options, widget_values_format);
+            expect(result.isSecondaryAxis).toBe(false);
+        });
+
+        it('should correctly detect if the given format is custom', () => {
+            const render_options = {
+                comboOptions: {
+                    seriesOptions: [
+                        { format: '#,###' },
+                        { format: '#,###' },
+                        { format: '#,###' },
+                    ],
+                },
+            };
+            const widget_values_format = '$#,###.###';
+            const result = highchartsRenderer.checkFormats(render_options, widget_values_format);
+            expect(result.isCustomFormat).toBe(true);
+        });
+
+        it('should correctly detect if the given format is not custom', () => {
+            const render_options = {
+                comboOptions: {
+                    seriesOptions: [
+                        { format: '$#,###' },
+                        { format: '$#,###.#' },
+                        { format: '$#,###.##' },
+                    ],
+                },
+            };
+            const widget_values_format = '$#,###';
+            const result = highchartsRenderer.checkFormats(render_options, widget_values_format);
+            expect(result.isCustomFormat).toBe(false);
+        });
+    });
+
+    describe('function isCustomValuesFormat', () => {
+        const render_options = {
+            comboOptions: {
+                seriesOptions: [
+                    { series: 'Profit', format: '#,###', secondaryAxis: false },
+                    { series: 'Sales', format: '#,###', secondaryAxis: true },
+                ]
+            }
+        };
+
+        it('should return true if new widget value formatting is enabled and the format is custom or there is no secondary axis', () => {
+            const widget_values_format = '$####.##';
+
+            highchartsRenderer.enabledNewWidgetValueFormatting = true;
+
+            const expectedValue = true;
+
+            const result = highchartsRenderer.isCustomValuesFormat(render_options, widget_values_format);
+
+            expect(result).toEqual(expectedValue);
+        });
+
+        it('should return false if new widget value formatting is disabled', () => {
+            const widget_values_format = '#,###';
+
+            highchartsRenderer.enabledNewWidgetValueFormatting = false;
+
+            const expectedValue = false;
+
+            const result = highchartsRenderer.isCustomValuesFormat(render_options, widget_values_format);
+
+            expect(result).toEqual(expectedValue);
+        });
+
+        it('should return false if the format is not custom and there is a secondary axis', () => {
+            const widget_values_format = '#,###';
+
+            highchartsRenderer.enabledNewWidgetValueFormatting = true;
+
+            const expectedValue = false;
+
+            const result = highchartsRenderer.isCustomValuesFormat(render_options, widget_values_format);
+
+            expect(result).toEqual(expectedValue);
+        });
+    });
+
+    describe('getRecordFormats', () => {
+        const render_options = {
+            comboOptions: {
+                seriesOptions: [
+                    { series: 'Profit', format: '$####.#', secondaryAxis: false },
+                    { series: 'Sales', format: '$####.##', secondaryAxis: true },
+                ]
+            }
+        };
+
+        it('should return an array of formats for the given record name', () => {
+            const recordName = 'Profit';
+
+            const expectedValue = ['$####.#'];
+
+            const result = highchartsRenderer.getRecordFormats(render_options, recordName);
+
+            expect(result).toEqual(expectedValue);
+        });
+
+        it('should return an empty array if there are no matching records', () => {
+            const recordName = 'Any';
+
+            const expectedValue = [];
+
+            const result = highchartsRenderer.getRecordFormats(render_options, recordName);
+
+            expect(result).toEqual(expectedValue);
+        });
+    });
 });