@datarailsshared/dr_renderer 1.2.322-dragons → 1.2.324

package/tests/highcharts_renderer.test.js

@@ -2,6 +2,10 @@ import * as JQuery from "jquery";
 import * as lodash from 'lodash';
 import moment from 'moment/min/moment.min';
 import tables from './mock/tables.json';
+import addInTables from './mock/add-in-tables.json';
+import addInFunctions from './mock/add-in-functions.json';
+import addInDynamicRanges from './mock/add-in-dynamic-ranges.json';
+import widgets from './mock/widgets.json';
 import initPivotTable from "../src/pivottable";
 import initDRPivotTable from "../src/dr_pivottable";
 
@@ -483,6 +487,7 @@ describe('highcharts_renderer', () => {
         let opts;
 
         beforeEach(() => {
+            highchartsRenderer.enabledNewWidgetValueFormatting = false;
             funcContext = { y: '12345.678' };
             opts = {}
         });
@@ -1563,6 +1568,228 @@ describe('highcharts_renderer', () => {
         });
     });
 
+    describe('function addTemplateDataToExTableOptions', () => {
+        it('should fill pivot options', () => {
+            const addInTable = lodash.cloneDeep(addInTables[0]);
+            const template = lodash.cloneDeep(lodash.find(tables, { id: addInTable.template_id }));
+            const uniqFields = lodash.uniqBy(lodash.concat(addInTable.fields, addInTable.filters), 'name');
+            const filtersWithoutFields = lodash.differenceBy(addInTable.filters, addInTable.fields, 'name');
+
+            highchartsRenderer.addTemplateDataToExTableOptions(template, addInTable);
+            expect(addInTable.pivot).toBeTruthy();
+            expect(addInTable.pivot.fieldsArray.length).toBe(template.fields.length - uniqFields.length);
+            expect(addInTable.pivot.selectedFieldsArray.length).toBe(addInTable.fields.length);
+            expect(addInTable.pivot.filtersArray.length).toBe(filtersWithoutFields.length);
+            expect(addInTable.pivot.calculatedValues.length).toBe(0);
+        });
+    });
+
+    describe('function addTemplateDataToDynamicRangeOptions', () => {
+        it('should fill pivot options', () => {
+            const dynamicRange = lodash.cloneDeep(addInDynamicRanges[0]);
+            const template = lodash.cloneDeep(lodash.find(tables, { id: dynamicRange.table_id }));
+            const uniqFields = lodash.uniqBy(lodash.concat(dynamicRange.fields, dynamicRange.filters), 'name');
+            const filtersWithoutFields = lodash.differenceBy(dynamicRange.filters, dynamicRange.fields, 'name');
+
+            highchartsRenderer.addTemplateDataToDynamicRangeOptions(template, dynamicRange);
+            expect(dynamicRange.pivot).toBeTruthy();
+            expect(dynamicRange.pivot.fieldsArray.length).toBe(template.fields.length - uniqFields.length);
+            expect(dynamicRange.pivot.selectedFieldsArray.length).toBe(dynamicRange.fields.length);
+            expect(dynamicRange.pivot.filtersArray.length).toBe(filtersWithoutFields.length);
+            expect(dynamicRange.pivot.calculatedValues.length).toBe(0);
+        });
+    });
+
+    describe('function addTemplateDataToFunctionOptions', () => {
+        it('should fill pivot options', () => {
+            const addInFunction = lodash.cloneDeep(addInFunctions[0]);
+            const template = lodash.cloneDeep(lodash.find(tables, { id: addInFunction.template_id }));
+
+            highchartsRenderer.addTemplateDataToFunctionOptions(template, addInFunction);
+            expect(addInFunction.pivot).toBeTruthy();
+
+            expect(addInFunction.pivot.fieldsArray.length).toBe(template.fields.length - addInFunction.filters.length  - addInFunction.vals.length);
+            expect(addInFunction.pivot.valuesArray.length).toBe(addInFunction.vals.length);
+            expect(addInFunction.pivot.filtersArray.length).toBe(addInFunction.filters.length);
+            expect(addInFunction.pivot.calculatedValues.length).toBe(addInFunction.calculated_values.length);
+        });
+    });
+
+    describe('function addTemplateDataToWidgetOptions', () => {
+        let widget;
+        let template;
+
+        beforeEach(() => {
+            widget = lodash.cloneDeep(widgets[0]);
+            template = lodash.cloneDeep(lodash.find(tables, { id: widget.template_id }));
+        });
+
+        it('should fill pivot options', () => {
+            const uniqFields = lodash.uniqBy(lodash.concat(widget.rows, widget.cols, widget.filters, widget.vals), 'name');
+            const uniqFieldsWithoutFilters = lodash.uniqBy(lodash.concat(widget.rows, widget.cols, widget.vals), 'name');
+            const filtersWithoutFields = lodash.differenceBy(widget.filters, uniqFieldsWithoutFilters, 'name');
+
+            highchartsRenderer.addTemplateDataToWidgetOptions(template, widget, false);
+
+            expect(widget.pivot).toBeTruthy();
+            expect(widget.pivot.calculatedValues.length).toBe(widget.calculated_values.length);
+            expect(widget.pivot.fieldsArray.length).toBe(template.fields.length - uniqFields.length);
+            expect(widget.pivot.axisArray.length).toBe(widget.cols.length);
+            expect(widget.pivot.legendArray.length).toBe(widget.rows.length);
+            expect(widget.pivot.valuesArray.length).toBe(widget.vals.length);
+            expect(widget.pivot.filtersArray.length).toBe(filtersWithoutFields.length);
+            expect(widget.pivot.filterIncludes).toBeDefined();
+            expect(widget.pivot.chartType).toBe(widget.chart_type);
+            expect(widget.pivot.chartOptions).toEqual(widget.options);
+            expect(widget.pivot.chartRender).not.toBe(null);
+        });
+
+        it('should not exclude filters if doNotRemoveFilters enabled', () => {
+            const uniqFields = lodash.uniqBy(lodash.concat(widget.rows, widget.cols, widget.vals), 'name');
+
+            highchartsRenderer.addTemplateDataToWidgetOptions(template, widget, true);
+
+            expect(widget.pivot.fieldsArray.length).toBe(template.fields.length - uniqFields.length);
+        });
+
+        it('should take old row data on second time', () => {
+            const rowData = { rowData: '123' };
+            const sorters = { sorters: '123' };
+            highchartsRenderer.addTemplateDataToWidgetOptions(template, widget, false);
+            widget.pivot.rowData = rowData;
+            widget.pivot.sorters = sorters;
+            highchartsRenderer.addTemplateDataToWidgetOptions(template, widget, false);
+            expect(widget.pivot.rowData).toBe(rowData);
+            expect(widget.pivot.sorters).toBe(sorters);
+        });
+    });
+
+    describe('function addFilterDataToField', () => {
+        let filterObj, fieldOb, includes;
+
+        beforeEach(() => {
+            filterObj = {
+                values: ['value1', 'value2'],
+                is_excluded: false,
+                show_in_graph: true,
+                override_global_filter: true,
+                allow_nulls: true
+            };
+            fieldOb = {
+                name: 'fieldName',
+                values: []
+            };
+            includes = {};
+        });
+
+        it('should set includes array for field when filter is not excluded', () => {
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.includes).toEqual(['value1', 'value2']);
+            expect(fieldOb.excludes).toBeUndefined();
+            expect(includes).toEqual({
+                fieldName: ['value1', 'value2']
+            });
+            expect(fieldOb.show_in_graph).toBe(true);
+            expect(fieldOb.override_global_filter).toBe(true);
+            expect(fieldOb.allow_nulls).toBe(true);
+        });
+
+        it('should set excludes array for field when filter is excluded', () => {
+            filterObj.is_excluded = true;
+
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.includes).toBeUndefined();
+            expect(fieldOb.excludes).toEqual(['value1', 'value2']);
+            expect(includes).toEqual({
+                fieldName: []
+            });
+            expect(fieldOb.show_in_graph).toBe(true);
+            expect(fieldOb.override_global_filter).toBe(true);
+            expect(fieldOb.allow_nulls).toBe(true);
+        });
+
+        it('should set values on field when datetype is not list', () => {
+            filterObj.values = {
+                datetype: {
+                    type: 'not list'
+                }
+            };
+
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.includes).toBeUndefined();
+            expect(fieldOb.excludes).toBeUndefined();
+            expect(fieldOb.values).toEqual(filterObj.values);
+            expect(fieldOb.show_in_graph).toBe(true);
+            expect(fieldOb.override_global_filter).toBe(true);
+            expect(fieldOb.allow_nulls).toBe(true);
+        });
+
+        it('should set values.val on filterObj when datetype is list', () => {
+            const values = ['list value 1', 'list value 2'];
+            filterObj.values = {
+                datetype: 'list',
+                val: values
+            };
+
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.includes).toEqual(values);
+            expect(fieldOb.excludes).toBeUndefined();
+            expect(filterObj.values).toEqual(values);
+            expect(fieldOb.show_in_graph).toBe(true);
+            expect(fieldOb.override_global_filter).toBe(true);
+            expect(fieldOb.allow_nulls).toBe(true);
+        });
+
+        it('should set values on field when type is advanced', () => {
+            filterObj.values = {
+                type: 'advanced'
+            };
+            filterObj.values.type = 'advanced';
+
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.includes).toBeUndefined();
+            expect(fieldOb.excludes).toBeUndefined();
+            expect(fieldOb.values).toEqual(filterObj.values);
+            expect(fieldOb.show_in_graph).toBe(true);
+            expect(fieldOb.override_global_filter).toBe(true);
+            expect(fieldOb.allow_nulls).toBe(true);
+        });
+
+        it('should set show_in_graph to false on field when filterObj.show_in_graph is false', () => {
+            filterObj.show_in_graph = false;
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.show_in_graph).toBeUndefined();
+            expect(fieldOb.override_global_filter).toBe(true);
+            expect(fieldOb.allow_nulls).toBe(true);
+        });
+
+        it('should set override_global_filter to false on field when filterObj.override_global_filter is false', () => {
+            filterObj.override_global_filter = false;
+
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.show_in_graph).toBe(true);
+            expect(fieldOb.override_global_filter).toBeUndefined();
+            expect(fieldOb.allow_nulls).toBe(true);
+        });
+
+
+        it('should set allow_nulls to false on field when filterObj.allow_nulls is false', () => {
+            filterObj.allow_nulls = false;
+            highchartsRenderer.addFilterDataToField(filterObj, fieldOb, includes);
+
+            expect(fieldOb.show_in_graph).toBe(true);
+            expect(fieldOb.override_global_filter).toBe(true);
+            expect(fieldOb.allow_nulls).toBeUndefined();
+        });
+    });
+
     describe('function getChartOptionsBySubType', () => {
         it('returns null for rich_text subtype', () => {
             const result = highchartsRenderer.getChartOptionsBySubType('rich_text');
@@ -1735,6 +1962,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -1781,6 +2009,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', () => {
@@ -1831,6 +2074,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');
+                    });
                 });
             });
 
@@ -1912,6 +2171,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -1958,6 +2218,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', () => {
@@ -2008,6 +2283,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');
+                    });
                 });
             });
 
@@ -2243,6 +2534,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -2291,6 +2583,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', () => {
@@ -2350,6 +2657,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');
+                    });
                 });
             });
 
@@ -2431,6 +2754,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -2477,6 +2801,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', () => {
@@ -2528,6 +2867,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');
+                    });
                 });
             });
 
@@ -2609,6 +2964,7 @@ describe('highcharts_renderer', () => {
                     });
 
                     it('Formats must be filled and uniq', () => {
+                        highchartsRenderer.enabledNewWidgetValueFormatting = false;
                         aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
                         expect(aggregatorObject.formats).toEqual(['####', '#,###']);
                     });
@@ -2655,6 +3011,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', () => {
@@ -2706,6 +3077,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.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');
+                    });
                 });
             });
         });
@@ -4291,4 +4678,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);
+        });
+    });
 });