@datarailsshared/dr_renderer 1.2.294 → 1.2.296

package/tests/highcharts_renderer.test.js

@@ -1,6 +1,7 @@
 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";
 
@@ -394,4 +395,3133 @@ describe('highcharts_renderer', () => {
             expect(highchartsRenderer.isSystemField(field)).toBe(false);
         });
     });
+
+    describe('function selfStartsWith', () => {
+        it('should return true when str starts with searchStr', () => {
+            expect(highchartsRenderer.selfStartsWith('hello world', 'hello')).toBe(true);
+        });
+
+        it('should return false when str does not start with searchStr', () => {
+            expect(highchartsRenderer.selfStartsWith('hello world', 'world')).toBe(false);
+        });
+
+        it('should return false when str is empty', () => {
+            expect(highchartsRenderer.selfStartsWith('', 'hello')).toBe(false);
+        });
+
+        it('should return true when searchStr is empty', () => {
+            expect(highchartsRenderer.selfStartsWith('hello world', '')).toBe(true);
+        });
+
+        it('should handle searchStr longer than str', () => {
+            expect(highchartsRenderer.selfStartsWith('hello', 'hello world')).toBe(false);
+        });
+
+        it('should handle non-string inputs', () => {
+            expect(highchartsRenderer.selfStartsWith(null, 'hello')).toBe(false);
+            expect(highchartsRenderer.selfStartsWith(undefined, 'hello')).toBe(false);
+            expect(highchartsRenderer.selfStartsWith(123, 'hello')).toBe(false);
+            expect(highchartsRenderer.selfStartsWith([], 'hello')).toBe(false);
+        });
+    });
+
+    describe('function getSpanWrapper', () => {
+        it('should return span element with value', () => {
+            expect(highchartsRenderer.getSpanWrapper('Hello')).toBe('<span>\u200EHello</span>');
+            expect(highchartsRenderer.getSpanWrapper('123')).toBe('<span>\u200E123</span>');
+            expect(highchartsRenderer.getSpanWrapper('')).toBe('<span>\u200E</span>');
+        });
+
+        it('should handle non-string inputs', () => {
+            expect(highchartsRenderer.getSpanWrapper(null)).toBe('<span>\u200Enull</span>');
+            expect(highchartsRenderer.getSpanWrapper(undefined)).toBe('<span>\u200Eundefined</span>');
+            expect(highchartsRenderer.getSpanWrapper(123)).toBe('<span>\u200E123</span>');
+            expect(highchartsRenderer.getSpanWrapper([])).toBe('<span>\u200E</span>');
+        });
+    });
+
+    describe('function encodeHTMLBrackets', () => {
+        it('should encode HTML brackets', () => {
+            expect(highchartsRenderer.encodeHTMLBrackets('Hello <World>')).toBe('Hello &lt;World&gt;');
+            expect(highchartsRenderer.encodeHTMLBrackets('<script>alert("hello");</script>')).toBe('&lt;script&gt;alert("hello");&lt;/script&gt;');
+            expect(highchartsRenderer.encodeHTMLBrackets('<h1>Title</h1>')).toBe('&lt;h1&gt;Title&lt;/h1&gt;');
+        });
+    });
+
+    describe('function getSingleValueAgg', () => {
+        it('should return correct aggfunc and base for Sum', () => {
+            const { aggfunc, base } = highchartsRenderer.getSingleValueAgg({ value: { value: 'Sum' } }, null, null);
+            expect(aggfunc).toBe(null);
+            expect(base).toBe(null);
+        });
+
+        it('should return correct aggfunc and base for Max', () => {
+            const { aggfunc, base } = highchartsRenderer.getSingleValueAgg({ value: { value: 'Max' } }, null, null);
+            expect(aggfunc(1, 2)).toBe(2);
+            expect(base).toBe(null);
+        });
+
+        it('should return correct aggfunc and base for Min', () => {
+            const { aggfunc, base } = highchartsRenderer.getSingleValueAgg({ value: { value: 'Min' } }, null, null);
+            expect(aggfunc(1, 2)).toBe(1);
+            expect(base).toBe(Number.MAX_VALUE);
+        });
+
+        it('should return correct aggfunc and base for Avg', () => {
+            const { aggfunc, base } = highchartsRenderer.getSingleValueAgg({ value: { value: 'Avg' } }, null, null);
+            const arr = [1, 2, 3];
+            expect(aggfunc(0, 1, 0, arr)).toBe(1);
+            expect(aggfunc(0, 2, 1, arr)).toBe(2);
+            expect(aggfunc(3, 3, 2, arr)).toBe(2);
+            expect(base).toBe(null);
+        });
+
+        it('should return correct aggfunc and base for Unique', () => {
+            const { aggfunc, base } = highchartsRenderer.getSingleValueAgg({ value: { value: 'Unique' } }, null, null);
+            expect(aggfunc('a', 'b')).toBe('a<br>b');
+            expect(base).toBe('');
+        });
+
+        it('should handle invalid input', () => {
+            const { aggfunc, base } = highchartsRenderer.getSingleValueAgg({ value: { value: 'Invalid' } }, null, null);
+            expect(aggfunc).toBe(null);
+            expect(base).toBe(null);
+        });
+    });
+
+    describe('function setTitleAndSubTitle', () => {
+        it('should set title to null when hideChartHeader is true', () => {
+            const chartOptions = { title: {}, subtitle: {} };
+            const opts = { chartOptions: { hideChartHeader: true } };
+            highchartsRenderer.setTitleAndSubTitle(chartOptions, opts);
+            expect(chartOptions.title.text).toBe(null);
+        });
+
+        it('should set title to custom value when chart_title is present', () => {
+            const chartOptions = { title: {}, subtitle: {} };
+            const opts = { chart_title: 'Custom Title', chartOptions: { hideChartHeader: false } };
+            highchartsRenderer.setTitleAndSubTitle(chartOptions, opts);
+            expect(chartOptions.title.text).toBe('Custom Title');
+        });
+
+        it('should set subtitle to custom value when subtitle is present in additionOptions', () => {
+            const chartOptions = { title: {}, subtitle: {} };
+            const additionOptions = { subtitle: { subtitle: 'Custom Subtitle' } };
+            highchartsRenderer.setTitleAndSubTitle(chartOptions, { chartOptions: { hideChartHeader: false } }, additionOptions);
+            expect(chartOptions.subtitle.text).toBe('Custom Subtitle');
+        });
+    });
+
+    describe('function handleGridLines', () => {
+        it('should not set grid lines when chartobj is not present', () => {
+            const chartOptions = { xAxis: {}, yAxis: {} };
+            highchartsRenderer.handleGridLines(null, chartOptions);
+            expect(chartOptions.xAxis.gridLineWidth).toBeUndefined();
+            expect(chartOptions.yAxis.gridLineWidth).toBeUndefined();
+        });
+
+        it('should not set grid lines when chartobj is present', () => {
+            const chartOptions = { };
+            highchartsRenderer.handleGridLines({ chart_grid : {} }, chartOptions);
+            expect(chartOptions.xAxis).toBeUndefined();
+            expect(chartOptions.yAxis).toBeUndefined();
+        });
+
+        it('should set grid lines when chartobj.show is true', () => {
+            const chartOptions = { xAxis: {}, yAxis: {} };
+            const additionOptions = { chart_grid: { show: true } };
+            highchartsRenderer.handleGridLines(additionOptions, chartOptions);
+            expect(chartOptions.xAxis.gridLineWidth).toBe(1);
+            expect(chartOptions.yAxis.gridLineWidth).toBe(1);
+            expect(chartOptions.xAxis.lineWidth).toBe(0);
+            expect(chartOptions.yAxis.lineWidth).toBe(0);
+        });
+
+        it('should not set grid lines when chartobj.show is false', () => {
+            const chartOptions = { xAxis: {}, yAxis: {} };
+            const additionOptions = { chart_grid: { show: false } };
+            highchartsRenderer.handleGridLines(additionOptions, chartOptions);
+            expect(chartOptions.xAxis.gridLineWidth).toBe(0);
+            expect(chartOptions.yAxis.gridLineWidth).toBe(0);
+            expect(chartOptions.xAxis.lineWidth).toBe(1);
+            expect(chartOptions.yAxis.lineWidth).toBe(1);
+        });
+    });
+
+    describe('function getCalculatedValueFormat', () => {
+        const calculatedFormats = {
+            colKey1: 'format1',
+            colKey2: 'format2',
+            rowKey1: 'format3',
+            rowKey2: 'format4',
+        };
+
+        it('should return an empty string if no calculatedFormats are provided', () => {
+            const result = highchartsRenderer.getCalculatedValueFormat(undefined, 'rowKey1', 'colKey1');
+            expect(result).toEqual('');
+        });
+
+        it('should return the format of a single row or column key', () => {
+            const result1 = highchartsRenderer.getCalculatedValueFormat(calculatedFormats, 'rowKey1', 'colKey1');
+            expect(result1).toEqual('format3');
+
+            const result2 = highchartsRenderer.getCalculatedValueFormat(calculatedFormats, 'rowKey2', 'colKey2');
+            expect(result2).toEqual('format4');
+        });
+
+        it('should return the format of an array of row or column keys', () => {
+            const result1 = highchartsRenderer.getCalculatedValueFormat(calculatedFormats, ['rowKey1', 'rowKey2'], 'colKey1');
+            expect(result1).toEqual('format4');
+
+            const result2 = highchartsRenderer.getCalculatedValueFormat(calculatedFormats, 'rowKey1', ['colKey1', 'colKey2']);
+            expect(result2).toEqual('format3');
+        });
+
+        it('should return an empty string if no format is found for the provided keys', () => {
+            const result = highchartsRenderer.getCalculatedValueFormat(calculatedFormats, 'nonexistentRowKey', 'nonexistentColKey');
+            expect(result).toEqual('');
+        });
+
+        it('should return an empty string if no calculated formats', () => {
+            const result = highchartsRenderer.getCalculatedValueFormat([], ['nonexistentRowKey'], ['nonexistentColKey']);
+            expect(result).toEqual('');
+        });
+    });
+
+    describe('function isRowKeyShouldBePercentage', () => {
+        const renderOptions = {
+            comboOptions: {
+                secondaryAxisSettings: {
+                    is_percentage: true
+                },
+                seriesOptions: [
+                    { series: 'series1', secondaryAxis: false },
+                    { series: 'series2', secondaryAxis: true }
+                ]
+            }
+        };
+
+        it('should return true if the row key has a corresponding series with secondaryAxis true', () => {
+            const rowKey = ['series2'];
+            const result = highchartsRenderer.isRowKeyShouldBePercentage(renderOptions, rowKey);
+            expect(result).toBe(true);
+        });
+
+        it('should return false if the row key does not have a corresponding series', () => {
+            const rowKey = ['series3'];
+            const result = highchartsRenderer.isRowKeyShouldBePercentage(renderOptions, rowKey);
+            expect(result).toBe(false);
+        });
+
+        it('should return false if the corresponding series has secondaryAxis false', () => {
+            const rowKey = ['series1'];
+            const result = highchartsRenderer.isRowKeyShouldBePercentage(renderOptions, rowKey);
+            expect(result).toBe(false);
+        });
+
+        it('should return false if renderOptions or comboOptions or secondaryAxisSettings is not defined', () => {
+            const rowKey = ['series2'];
+            const result = highchartsRenderer.isRowKeyShouldBePercentage(null, rowKey);
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('function ignoreIfCalculatedValue', () => {
+        let data;
+        let rowKey;
+        let colKey;
+        let record;
+        let associatedFields;
+        let renderOptions;
+        const isGraph = false;
+
+        beforeEach(() => {
+            data = {
+                colAttrs: ['col1', 'col2'],
+                rowAttrs: ['row1', 'row2']
+            }
+            rowKey = ['row1value', 'row2value'];
+            colKey = ['col1value', 'col2value'];
+            record = {
+                row1: 'row1value',
+                row2: 'row2value',
+                col1: 'col1value',
+                col2: 'col2value',
+                DR_Values: 123
+            }
+            associatedFields = {
+                row1: ['row1value', 'row1value2'],
+                row2: ['row2value', 'row2value2']
+            }
+            renderOptions = {
+                chartOptions: {
+                    table_options: {
+                        eliminate_calc_totals: true
+                    }
+                }
+            }
+        });
+
+        it('should return false if eliminate_calc_totals is false', () => {
+            renderOptions.chartOptions.table_options.eliminate_calc_totals = false;
+            const result = highchartsRenderer.ignoreIfCalculatedValue(data, rowKey, colKey, record, associatedFields, renderOptions, isGraph);
+            expect(result).toBe(false);
+        });
+
+        it('should return false if colAttrs and rowAttrs have same length as colKey and rowKey', () => {
+            const result = highchartsRenderer.ignoreIfCalculatedValue(data, rowKey, colKey, record, associatedFields, renderOptions, isGraph);
+            expect(result).toBe(false);
+        });
+
+        it('should return true if associatedFields matches record keys and eliminate_calc_totals is true', () => {
+            const rKeys = [...rowKey];
+            const cKeys = [...colKey, 'col3value'];
+            record.row1 = 'row1value2';
+            const result = highchartsRenderer.ignoreIfCalculatedValue(data, rKeys, cKeys, record, associatedFields, renderOptions, isGraph);
+            expect(result).toBe(true);
+        });
+
+        it('should return true if associatedFields matches DR_Values and eliminate_calc_totals is true', () => {
+            const rKeys = [...rowKey, 'row3value'];
+            const cKeys = [...colKey];
+            record.row1 = 'test';
+            record.DR_Values = 'row1value2';
+            const result = highchartsRenderer.ignoreIfCalculatedValue(data, rKeys, cKeys, record, associatedFields, renderOptions, isGraph);
+            expect(result).toBe(true);
+        });
+
+        it('should return false if isGraph is true', () => {
+            const result = highchartsRenderer.ignoreIfCalculatedValue(data, rowKey, colKey, record, associatedFields, renderOptions, true);
+            expect(result).toBe(false);
+        });
+
+        it('should return false if associatedFields are empty', () => {
+            const result = highchartsRenderer.ignoreIfCalculatedValue(data, rowKey, colKey, record, associatedFields, renderOptions, isGraph);
+            expect(result).toBe(false);
+        });
+    });
+
+    describe('function getAxis', () => {
+        it('returns the given axis if transpose_table is false', () => {
+            const opts = { rendererOptions: { chartOptions: { table_options: { transpose_table: false } } }, isTable: true };
+            expect(highchartsRenderer.getAxis('row_total', opts)).toEqual('row_total');
+        });
+
+        it('returns the opposite axis if transpose_table is true and axis is col_total', () => {
+            const opts = { rendererOptions: { chartOptions: { table_options: { transpose_table: true } } }, isTable: true };
+            expect(highchartsRenderer.getAxis('col_total', opts)).toEqual('row_total');
+        });
+
+        it('returns the opposite axis if farceIsTable is true', () => {
+            const opts = { rendererOptions: { chartOptions: { table_options: { transpose_table: true } } }, isTable: false };
+            expect(highchartsRenderer.getAxis('col_total', opts, true)).toEqual('row_total');
+        });
+
+        it('returns the opposite axis if farceIsTable is true for row_total', () => {
+            const opts = { rendererOptions: { chartOptions: { table_options: { transpose_table: true } } }, isTable: false };
+            expect(highchartsRenderer.getAxis('row_total', opts, true)).toEqual('col_total');
+        });
+    });
+
+    describe('function sanitizeOptions', () => {
+        it('should decode chart_title property in rendererOptions', () => {
+            const opts = {
+                rendererOptions: {
+                    chart_title: 'Title &amp; subtitle'
+                }
+            };
+            highchartsRenderer.sanitizeOptions(opts);
+            expect(opts.rendererOptions.chart_title).toBe('Title & subtitle');
+        });
+
+        it('should decode subtitle property in chartOptions', () => {
+            const opts = {
+                chartOptions: {
+                    subtitle: {
+                        subtitle: 'Subtitle &amp; subtitle'
+                    }
+                }
+            };
+            highchartsRenderer.sanitizeOptions(opts);
+            expect(opts.chartOptions.subtitle.subtitle).toBe('Subtitle & subtitle');
+        });
+
+        it('should decode subtitle property in rendererOptions.chartOptions', () => {
+            const opts = {
+                rendererOptions: {
+                    chartOptions: {
+                        subtitle: {
+                            subtitle: 'Subtitle &amp; subtitle'
+                        }
+                    }
+                }
+            };
+            highchartsRenderer.sanitizeOptions(opts);
+            expect(opts.rendererOptions.chartOptions.subtitle.subtitle).toBe('Subtitle & subtitle');
+        });
+
+        it('should not change the options if no property to decode', () => {
+            const opts = {
+                chartOptions: {
+                    chart_type: 'column'
+                }
+            };
+            highchartsRenderer.sanitizeOptions(opts);
+            expect(opts).toEqual({
+                chartOptions: {
+                    chart_type: 'column'
+                }
+            });
+        });
+    });
+
+    describe('function getIconsForTotalOptions', () => {
+        const options = {
+            total_value_options: {
+                filter_options: {
+                    axis: 'row'
+                }
+            }
+        };
+
+        it('should return filter icon for matching axis', () => {
+            const axis = 'row'
+            const expected = '<i class="fa fa-filter"></i>'
+            const result = highchartsRenderer.getIconsForTotalOptions(options, axis)
+            expect(result).toEqual(expected)
+        });
+
+        it('should return empty string for non-matching axis', () => {
+            const axis = 'col'
+            const expected = ''
+            const result = highchartsRenderer.getIconsForTotalOptions(options, axis)
+            expect(result).toEqual(expected)
+        });
+
+        it('should return empty string for missing filter options', () => {
+            const axis = 'row'
+            const options = {}
+            const expected = ''
+            const result = highchartsRenderer.getIconsForTotalOptions(options, axis)
+            expect(result).toEqual(expected)
+        });
+    });
+
+    describe('function getFieldNameForTable', () => {
+        it('should return a function if remove_underscores is false', () => {
+            const opt = {
+                rendererOptions: {
+                    chartOptions: {
+                        table_options: {
+                            remove_underscores: false
+                        }
+                    }
+                }
+            };
+            const result = highchartsRenderer.getFieldNameForTable(opt);
+            expect(result).toBe(highchartsRenderer.getFieldName);
+        });
+
+        it('should return a function that removes underscores from field names if remove_underscores is true', () => {
+            const opt = {
+                rendererOptions: {
+                    chartOptions: {
+                        table_options: {
+                            remove_underscores: true
+                        }
+                    }
+                }
+            };
+            const result = highchartsRenderer.getFieldNameForTable(opt);
+            const field = 'field_name_with_underscores';
+            const expectedResult = 'field name with underscores';
+            expect(result(field)).toBe(expectedResult);
+            const emptyName = '';
+            expect(result(emptyName)).toBe(emptyName);
+        });
+
+        it('should return highchartsRenderer.getFieldName function if option is missing', () => {
+            const opt = {};
+            const result = highchartsRenderer.getFieldNameForTable(opt);
+            expect(result).toBe(highchartsRenderer.getFieldName);
+        });
+    });
+
+    describe("function getFieldName", () => {
+        it("returns empty string if given an empty string", () => {
+            expect(highchartsRenderer.getFieldName("")).toEqual("");
+        });
+
+        it("returns the same string if no replacements are needed", () => {
+            expect(highchartsRenderer.getFieldName("Test Field")).toEqual("Test Field");
+        });
+
+        it("replaces specific strings with new names", () => {
+            expect(highchartsRenderer.getFieldName("DR_Values")).toEqual("Values");
+            expect(highchartsRenderer.getFieldName("Submission_Date")).toEqual("Submission Date");
+            expect(highchartsRenderer.getFieldName("VT_Day")).toEqual("Day (Tag)");
+        });
+
+        it("adds '(Dimension)' if field name starts with 'DT_'", () => {
+            expect(highchartsRenderer.getFieldName("DT_Test")).toEqual("Test (Dimension)");
+        });
+
+        it("adds '(Scenario)' if field name starts with 'dr_scenario_' and doesn't have 'for_value_' in it", () => {
+            expect(highchartsRenderer.getFieldName("dr_scenario_Test")).toEqual("Test (Scenario)");
+        });
+
+        it("no adds '(Scenario)' and uses 'for_value_' to create a new name if field name starts with 'dr_scenario_' and has 'for_value_' in it", () => {
+            expect(highchartsRenderer.getFieldName("dr_scenario_Test_for_value_X")).toEqual("X (Test)");
+
+        });
+        it("adds '(Scenario)' and uses 'for_value_' to create a new name if field name starts with 'dr_scenario_' and has 'for_value_' in it", () => {
+            expect(highchartsRenderer.getFieldName("dr_scenario_X")).toEqual("X (Scenario)");
+        });
+
+        it("adds '(Split)' if field name contains '_splitted_'", () => {
+            expect(highchartsRenderer.getFieldName("Test_splitted_Fiscal_quarter")).toEqual("Test Fiscal Quarter (Split)");
+        });
+    });
+
+    describe('function checkFreezePanesAvaliable', () => {
+        let pivotView;
+
+        beforeEach(() => {
+            pivotView = document.createElement('div');
+            pivotView.innerHTML = `
+                <div class="pivot-div">
+                    <table class="pvtTable">
+                        <thead>
+                            <tr>
+                                <th class="axis-freeze-pane" style="width: 100px;"></th>
+                                <th class="horizontal-freeze-pane" style="width: 100px;"></th>
+                                <th style="width: 500px;"></th>
+                            </tr>
+                        </thead>
+                    </table>
+                </div>
+            `;
+        });
+
+        it('should set dataset.canFreezePanes to false when total width of frozen columns exceeds table width', () => {
+            const tableContainer = pivotView.querySelector('.pivot-div');
+            const expectedDataset = { canFreezePanes: 'false' };
+
+            highchartsRenderer.checkFreezePanesAvaliable(pivotView);
+            expect(tableContainer.dataset.canFreezePanes).toEqual(expectedDataset.canFreezePanes);
+        });
+
+        it('should remove dataset.canFreezePanes when total width of frozen columns is less than table width', () => {
+            const tableContainer ={
+                dataset: { canFreezePanes: "false" },
+                offsetWidth: 1000
+            };
+
+            const _pivotView = {
+                querySelector: (p) => p === '.pivot-div' ? tableContainer : null
+            };
+            highchartsRenderer.checkFreezePanesAvaliable(_pivotView);
+
+            expect(tableContainer.dataset.canFreezePanes).toEqual(undefined);
+        });
+
+        it('should not set dataset.canFreezePanes when pivotView or pivotView.querySelector is undefined', () => {
+            expect(highchartsRenderer.checkFreezePanesAvaliable(null)).toEqual(undefined);
+        });
+    });
+
+    describe('function getOnlyIncludedOfField', () => {
+        it('returns includes array if it exists', () => {
+            const fieldObj = {
+                includes: ['foo', 'bar'],
+                values: ['foo', 'bar', 'baz'],
+            };
+            expect(highchartsRenderer.getOnlyIncludedOfField(fieldObj)).toEqual(['foo', 'bar']);
+        });
+
+        it('returns values array with excludes removed if excludes exists', () => {
+            const fieldObj = {
+                excludes: ['bar', 'baz'],
+                values: ['foo', 'bar', 'baz'],
+            };
+            expect(highchartsRenderer.getOnlyIncludedOfField(fieldObj)).toEqual(['foo']);
+        });
+
+        it('returns null if neither includes nor excludes exists', () => {
+            const fieldObj = {
+                values: ['foo', 'bar', 'baz'],
+            };
+            expect(highchartsRenderer.getOnlyIncludedOfField(fieldObj)).toBeNull();
+        });
+    });
+
+    describe('function createOneWidgetField', () => {
+        const template_field = {
+            name: 'field',
+            id: 123,
+            type: 'string',
+            format: null,
+            sorting: null,
+            has_drilldown: false,
+            is_calculated: false,
+            values: [],
+            date_field_before_split: null,
+            mandatory: false,
+            category: 'cat1',
+            is_hidden: false,
+            description: 'description',
+        };
+
+        it('returns an object with expected properties', () => {
+            const result = highchartsRenderer.createOneWidgetField(template_field);
+
+            expect(result).toHaveProperty('name', 'field');
+            expect(result).toHaveProperty('id', 123);
+            expect(result).toHaveProperty('type', 'string');
+            expect(result).toHaveProperty('format', null);
+            expect(result).toHaveProperty('sorting', null);
+            expect(result).toHaveProperty('has_drilldown', false);
+            expect(result).toHaveProperty('is_calculated', false);
+            expect(result).toHaveProperty('values', []);
+            expect(result).toHaveProperty('new_name', 'field');
+            expect(result).toHaveProperty('name_class', 'blue_filed');
+            expect(result).toHaveProperty('date_field_before_split', null);
+            expect(result).toHaveProperty('mandatory', false);
+            expect(result).toHaveProperty('category', 'cat1');
+            expect(result).toHaveProperty('is_hidden', false);
+            expect(result).toHaveProperty('description', 'description');
+            expect(result).toHaveProperty('description_tooltip');
+        });
+    });
+
+    describe('function getDescriptionAndHintValuesTooltip', () => {
+        it('returns only field name if no description or hint values are present', () => {
+            const field = {
+                name: 'foo',
+            };
+            const tooltip = highchartsRenderer.getDescriptionAndHintValuesTooltip(field);
+            expect(tooltip).toEqual('foo');
+        });
+
+        it('returns description if present and no hint values are present', () => {
+            const field = {
+                name: 'foo',
+                description: 'This is a field description.',
+            };
+            const tooltip = highchartsRenderer.getDescriptionAndHintValuesTooltip(field);
+            expect(tooltip).toEqual('Description:\nThis is a field description.');
+        });
+
+        it('returns hint values if present and no description is present', () => {
+            const field = {
+                name: 'foo',
+                usage_info: {
+                    data_info: {
+                        samples: ['bar', 'baz'],
+                        samples_formatted: ['Bar', 'Baz'],
+                    },
+                },
+            };
+            const tooltip = highchartsRenderer.getDescriptionAndHintValuesTooltip(field);
+            expect(tooltip).toEqual('Hint values:\nBar, Baz');
+        });
+
+        it('returns both description and hint values if present', () => {
+            const field = {
+                name: 'foo',
+                description: 'This is a field description.',
+                usage_info: {
+                    data_info: {
+                        samples: ['bar', 'baz'],
+                        samples_formatted: ['Bar', 'Baz'],
+                    },
+                },
+            };
+            const tooltip = highchartsRenderer.getDescriptionAndHintValuesTooltip(field);
+            expect(tooltip).toEqual('Description:\nThis is a field description.\n\nHint values:\nBar, Baz');
+        });
+    });
+
+    describe('function getFieldColorClass', () => {
+        it('should return "green_field" if field is not a system field and not mandatory', () => {
+            const field = {
+                name: 'field1',
+                mandatory: false
+            };
+            const result = highchartsRenderer.getFieldColorClass(field);
+            expect(result).toBe('green_field');
+        });
+
+        it('should return "blue_filed" if field is a system field and not mandatory', () => {
+            const field = {
+                name: 'System_Field',
+                mandatory: false,
+                isSystem: true
+            };
+            const result = highchartsRenderer.getFieldColorClass(field);
+            expect(result).toBe('blue_filed');
+        });
+
+        it('should return "green_field mandatoryfieldborder" if field is not a system field and is mandatory', () => {
+            const field = {
+                name: 'field2',
+                mandatory: true
+            };
+            const result = highchartsRenderer.getFieldColorClass(field);
+            expect(result).toBe('green_field mandatoryfieldborder ');
+        });
+
+        it('should return "blue_filed mandatoryfieldborder" if field is a system field and is mandatory', () => {
+            const field = {
+                name: 'System_Field',
+                mandatory: true,
+                isSystem: true
+            };
+            const result = highchartsRenderer.getFieldColorClass(field);
+            expect(result).toBe('blue_filed mandatoryfieldborder ');
+        });
+    });
+
+    describe('function getMiniTemplateObj', () => {
+        it('returns an object with only the id property', () => {
+            const template = {
+                id: 1,
+                name: 'Template 1'
+            }
+            const miniTemplateObj = highchartsRenderer.getMiniTemplateObj(template)
+            expect(miniTemplateObj).toEqual({ id: 1 })
+        })
+    });
+
+    describe('function decodeTemplates', () => {
+        it('should decode tables with fields and others propperties', () => {
+            let templates = lodash.cloneDeep(tables);
+            highchartsRenderer.decodeTemplates (templates);
+            expect(templates[0].name).toBe('Superstore&data');
+        });
+    });
+
+    describe('function setWidgetFieldsToTemplate', () => {
+        it('should set widget fields to selected template if not exists', () => {
+            const selectedTemplate = {
+                id: 1,
+                fields: [...tables[0].fields],
+                widget_fields: null
+            };
+
+            highchartsRenderer.setWidgetFieldsToTemplate(selectedTemplate);
+
+            expect(selectedTemplate.widget_fields.length).toBe(tables[0].fields.length);
+        });
+
+        it('shouldn\'t set new widget fields if already exist exists', () => {
+            const selectedTemplate = {
+                id: 1,
+                fields: [...tables[0].fields],
+                widget_fields: [{}]
+            };
+
+            highchartsRenderer.setWidgetFieldsToTemplate(selectedTemplate);
+
+            expect(selectedTemplate.widget_fields.length).toBe(1);
+        });
+    });
+
+    describe('function setWidgetRawData', () => {
+        it('should create widget_raw_data property if it does not exist', () => {
+            const selectedTemplate = {
+                raw_data: [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }],
+                fields: [{ name: 'name', type: 'string', format: '' }, { name: 'age', type: 'number', format: '' }]
+            };
+
+            highchartsRenderer.setWidgetRawData(selectedTemplate);
+
+            expect(selectedTemplate.widget_raw_data).toBeDefined();
+        });
+
+        it('should map raw_data to widget_raw_data property', () => {
+            const selectedTemplate = {
+                raw_data: [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }],
+                fields: [{ name: 'name', type: 'string', format: '' }, { name: 'age', type: 'number', format: '' }]
+            };
+
+            highchartsRenderer.setWidgetRawData(selectedTemplate);
+
+            expect(selectedTemplate.widget_raw_data).toEqual([{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }]);
+        });
+
+        it('should return raw_data values formatted based on their type and format', () => {
+            const selectedTemplate = {
+                raw_data: [{ name: 'John', age: 30.5 }, { name: 'Jane', age: 25 }],
+                fields: [{ name: 'name', type: 'string', format: '' }, { name: 'age', type: 'number', format: '0.00' }]
+            };
+
+            highchartsRenderer.setWidgetRawData(selectedTemplate);
+
+            expect(selectedTemplate.widget_raw_data[0].name).toBe('John');
+            expect(selectedTemplate.widget_raw_data[0].age).toBe(30.5);
+            expect(selectedTemplate.widget_raw_data[1].name).toBe('Jane');
+            expect(selectedTemplate.widget_raw_data[1].age).toBe(25);
+        });
+
+        it('shouldn\'t create widget_raw_data if it exists', () => {
+            const selectedTemplate = {
+                widget_raw_data: [{}],
+                raw_data: [{ name: 'John', age: 30 }, { name: 'Jane', age: 25 }],
+                fields: [{ name: 'name', type: 'string', format: '' }, { name: 'age', type: 'number', format: '' }]
+            };
+
+            highchartsRenderer.setWidgetRawData(selectedTemplate);
+
+            expect(selectedTemplate.widget_raw_data.length).toBe(1);
+        });
+    });
+
+    describe("function objectCopyJsonMethod", () => {
+        it("should return null for null input", () => {
+            expect(highchartsRenderer.objectCopyJsonMethod(null)).toBe(0);
+        });
+
+        it("should return a copy of the object", () => {
+            const obj = { a: 1, b: 2 };
+            const objCopy = highchartsRenderer.objectCopyJsonMethod(obj);
+            expect(objCopy).toEqual(obj);
+            expect(objCopy).not.toBe(obj);
+        });
+
+        it("should return a copy of the array", () => {
+            const arr = [1, 2, 3];
+            const arrCopy = highchartsRenderer.objectCopyJsonMethod(arr);
+            expect(arrCopy).toEqual(arr);
+            expect(arrCopy).not.toBe(arr);
+        });
+    });
+
+    describe('function aggregators', () => {
+        const aggregatorsIds = ['SUM', 'COUNT', 'COUNT_UNIQUE', 'UNIQUE_VALUES', 'AVG', 'MIN', 'MAX'];
+
+        it('Count and names', () => {
+           expect(highchartsRenderer.aggregators.length).toBe(7);
+           expect(lodash.map(highchartsRenderer.aggregators, agg => agg.id)).toEqual(aggregatorsIds);
+        });
+
+        it('function getAggregatorFunctionById', () => {
+            expect(highchartsRenderer.getAggregatorFunctionById(aggregatorsIds[0])).toBe(highchartsRenderer.rhPivotAggregatorSum);
+            expect(highchartsRenderer.getAggregatorFunctionById(aggregatorsIds[1])).toBe(highchartsRenderer.rhPivotCount);
+            expect(highchartsRenderer.getAggregatorFunctionById(aggregatorsIds[2])).toBe(highchartsRenderer.rhPivotCount);
+            expect(highchartsRenderer.getAggregatorFunctionById(aggregatorsIds[3])).toBe(highchartsRenderer.rhPivotAggregatorUniqValues);
+            expect(highchartsRenderer.getAggregatorFunctionById(aggregatorsIds[4])).toBe(highchartsRenderer.rhPivotAggregatorAverage);
+            expect(highchartsRenderer.getAggregatorFunctionById(aggregatorsIds[5])).toBe(highchartsRenderer.rhPivotAggregatorMin);
+            expect(highchartsRenderer.getAggregatorFunctionById(aggregatorsIds[6])).toBe(highchartsRenderer.rhPivotAggregatorMax);
+            expect(highchartsRenderer.getAggregatorFunctionById('nonExistAggregator')).toBe(undefined);
+        });
+
+        it('function getAggregatorNameById', () => {
+            expect(highchartsRenderer.getAggregatorNameById(aggregatorsIds[0])).toBe('Sum');
+            expect(highchartsRenderer.getAggregatorNameById(aggregatorsIds[1])).toBe('Count');
+            expect(highchartsRenderer.getAggregatorNameById(aggregatorsIds[2])).toBe('Count Unique');
+            expect(highchartsRenderer.getAggregatorNameById(aggregatorsIds[3])).toBe('Unique Values');
+            expect(highchartsRenderer.getAggregatorNameById(aggregatorsIds[4])).toBe('Average');
+            expect(highchartsRenderer.getAggregatorNameById(aggregatorsIds[5])).toBe('Minimum');
+            expect(highchartsRenderer.getAggregatorNameById(aggregatorsIds[6])).toBe('Maximum');
+            expect(highchartsRenderer.getAggregatorNameById('nonExistAggregator')).toBe('');
+        });
+
+        describe('function setDefaultAggregator', () => {
+            const field = {};
+
+            it('Integer field type', ()=> {
+                field.type = 'Integer';
+                highchartsRenderer.setDefaultAggregator(field);
+                expect(field.aggregator).toBe(aggregatorsIds[0]);
+            });
+
+            it('Float field type', ()=> {
+                field.type = 'Float';
+                highchartsRenderer.setDefaultAggregator(field);
+                expect(field.aggregator).toBe(aggregatorsIds[0]);
+            });
+
+            it('Non number field type', ()=> {
+                field.type = 'Text';
+                highchartsRenderer.setDefaultAggregator(field);
+                expect(field.aggregator).toBe(aggregatorsIds[3]);
+            });
+        });
+
+        describe('function getValueLabel', () => {
+            const field = {
+                new_name: 'name'
+            };
+
+            it('Field with aggregator should return aggregator name with new field name', ()=> {
+                field.aggregator = aggregatorsIds[4];
+                expect(highchartsRenderer.getValueLabel(field)).toBe('Average of name');
+            });
+
+            it('Number field without aggregator should return aggregator name with new field name', ()=> {
+                field.aggregator = null;
+                field.type = 'Float';
+                expect(highchartsRenderer.getValueLabel(field)).toBe('Sum of name');
+            });
+
+            it('Text field without aggregator should return aggregator name with new field name', ()=> {
+                field.aggregator = null;
+                field.type = 'Text';
+                expect(highchartsRenderer.getValueLabel(field)).toBe('Unique Values of name');
+            });
+        });
+
+        describe('Aggregators functions', () => {
+            describe('Sum aggregator', () => {
+                let arg;
+                let widget_values_format;
+                let is_graph;
+                let render_options;
+                let calculated_info;
+                let aggregator;
+                let aggregatorObject;
+
+                beforeEach(() => {
+                    arg = ['Profit'];
+                    widget_values_format = '"$"####.##';
+                    is_graph = true;
+                    render_options = {};
+                    calculated_info = {
+                        "formats": {
+                            "Average category": null,
+                            "Region average": "####.##%"
+                        },
+                        "associated_fields": {
+                            "Category": [
+                                "Average category"
+                            ],
+                            "Region": [
+                                "Region average"
+                            ]
+                        }
+                    };
+
+                    aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, render_options, calculated_info);
+                    aggregatorObject = aggregator({}, '', '');
+                });
+
+                it('Aggregation object structure', () => {
+                    expect(aggregatorObject.sum).toBe(0);
+                    expect(aggregatorObject.ignoreValue).toBe(false);
+                    expect(aggregatorObject.data_types).toEqual([]);
+                    expect(aggregatorObject.formats).toEqual([]);
+                    expect(aggregatorObject.has_errors).toBe(false);
+                    expect(aggregatorObject.widget_values_format).toBe(widget_values_format);
+                    expect(aggregatorObject.calculated_formats).toBe(calculated_info.formats);
+                    expect(aggregatorObject.isChangeable).toBe(false);
+                    expect(aggregatorObject.numInputs).toBe(0);
+                    expect(typeof aggregatorObject.push).toBe('function');
+                    expect(typeof aggregatorObject.value).toBe('function');
+                    expect(typeof aggregatorObject.format).toBe('function');
+                });
+
+                it('numInputs should be 1 if there are no argument', () => {
+                    const agg = highchartsRenderer.rhPivotAggregatorSum([null], widget_values_format, is_graph, render_options, calculated_info);
+                    const aggObject = agg({}, '', '');
+                    expect(aggObject.numInputs).toBe(1);
+                });
+
+                describe('Push method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should be error if wrong data_types', () => {
+                        aggregatorObject.push({
+                            data_types: ['d', '1']
+                        });
+                        expect(aggregatorObject.has_errors).toBe(true);
+                    });
+
+                    it('Sum should be NaN if value is string', () => {
+                        aggregatorObject.push({Profit: 'incorrectValue'});
+                        expect(aggregatorObject.sum).toBe(NaN);
+                    });
+
+                    it('Data types must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, data_types: ['1', '1', '2']});
+                        expect(aggregatorObject.data_types).toEqual(['1', '2']);
+                    });
+
+                    it('Formats must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
+                        expect(aggregatorObject.formats).toEqual(['####', '#,###']);
+                    });
+
+                    it('Value should be a sum of records when server calculation disabled', () => {
+                        highchartsRenderer.useTotalsCalculation = false;
+                        aggregatorObject.push({Profit: 10});
+                        aggregatorObject.push({Profit: 20});
+                        expect(aggregatorObject.sum).toEqual(30);
+                    });
+
+                    it('Value should be a last record value when server calculation enabled', () => {
+                        highchartsRenderer.useTotalsCalculation = true;
+                        aggregatorObject.push({Profit: 10});
+                        aggregatorObject.push({Profit: 20});
+                        expect(aggregatorObject.sum).toEqual(20);
+                    });
+
+                    it('Widget values format must be redefined if row key should be percentage', () => {
+                        const options = {
+                            comboOptions: {
+                                secondaryAxisSettings: {
+                                    is_percentage: true
+                                },
+                                seriesOptions: [{series: 'Region', secondaryAxis: true}]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region'], '');
+                        aggregatorObject.push({Profit: 20, Region: 'Central'});
+                        expect(aggregatorObject.widget_values_format).toEqual('#,###%');
+                    });
+
+                    it('Value must be ignored if calculated totals disabled', () => {
+                        const options = {
+                            chartOptions: {
+                                table_options: {
+                                    eliminate_calc_totals: true
+                                }
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, false, options, calculated_info);
+                        aggregatorObject = aggregator({colAttrs: [], rowAttrs: []}, ['Region average'], '');
+                        aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
+                        expect(aggregatorObject.ignoreValue).toBe(true);
+                    });
+                });
+
+                describe('Value method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return null if ignore', () => {
+                        aggregatorObject.ignoreValue = true;
+                        expect(aggregatorObject.value()).toBe(null);
+                    });
+
+                    it('Should return value', () => {
+                        aggregatorObject.ignoreValue = false;
+                        expect(aggregatorObject.value()).toBe(0);
+                    });
+                });
+
+                describe('Format method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return empty string if null or undefined', () => {
+                        expect(aggregatorObject.format(null, false)).toBe('');
+                        expect(aggregatorObject.format(undefined, false)).toBe('');
+                    });
+
+                    it('Should return ERROR if has_errors and not only formats', () => {
+                        aggregatorObject.has_errors = true;
+                        expect(aggregatorObject.format(123, false)).toBe('####ERROR####');
+                    });
+
+                    it('Should return General format if there are no widget_values_format', () => {
+                        aggregatorObject.widget_values_format = null;
+                        expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                    });
+
+                    it('Should return widget format if it\'s not calculated value', () => {
+                        aggregatorObject.widget_values_format = '\"$\"#,###.###';
+                        expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                    });
+
+                    it('Should return calculated value format if it\'s calculated value', () => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorSum(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region average'], '');
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                    });
+                });
+            });
+
+            describe('Count aggregator', () => {
+                let arg;
+                let widget_values_format;
+                let is_graph;
+                let render_options;
+                let calculated_info;
+                let aggregator;
+                let aggregatorObject;
+
+                beforeEach(() => {
+                    arg = ['Profit'];
+                    widget_values_format = '"$"####.##';
+                    is_graph = true;
+                    render_options = {};
+                    calculated_info = {
+                        "formats": {
+                            "Average category": null,
+                            "Region average": "####.##%"
+                        },
+                        "associated_fields": {
+                            "Category": [
+                                "Average category"
+                            ],
+                            "Region": [
+                                "Region average"
+                            ]
+                        }
+                    };
+
+                    aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, render_options, calculated_info);
+                    aggregatorObject = aggregator({}, '', '');
+                });
+
+                it('Aggregation object structure', () => {
+                    expect(aggregatorObject.sum).toBe(0);
+                    expect(aggregatorObject.ignoreValue).toBe(false);
+                    expect(aggregatorObject.data_types).toEqual([]);
+                    expect(aggregatorObject.formats).toEqual([]);
+                    expect(aggregatorObject.has_errors).toBe(false);
+                    expect(aggregatorObject.widget_values_format).toBe(widget_values_format);
+                    expect(aggregatorObject.calculated_formats).toBe(calculated_info.formats);
+                    expect(aggregatorObject.isChangeable).toBe(false);
+                    expect(aggregatorObject.numInputs).toBe(0);
+                    expect(typeof aggregatorObject.push).toBe('function');
+                    expect(typeof aggregatorObject.value).toBe('function');
+                    expect(typeof aggregatorObject.format).toBe('function');
+                });
+
+                it('numInputs should be 1 if there are no argument', () => {
+                    const agg = highchartsRenderer.rhPivotCount([null], widget_values_format, is_graph, render_options, calculated_info);
+                    const aggObject = agg({}, '', '');
+                    expect(aggObject.numInputs).toBe(1);
+                });
+
+                describe('Push method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    // it('Should be error if wrong data_types', () => {
+                    //     aggregatorObject.push({
+                    //         data_types: ['d', '1']
+                    //     });
+                    //     expect(aggregatorObject.has_errors).toBe(true);
+                    // });
+
+                    // it('Sum should be NaN if value is string', () => {
+                    //     aggregatorObject.push({Profit: 'incorrectValue'});
+                    //     expect(aggregatorObject.sum).toBe(NaN);
+                    // });
+
+                    it('Data types must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, data_types: ['1', '1', '2']});
+                        expect(aggregatorObject.data_types).toEqual(['1', '2']);
+                    });
+
+                    it('Formats must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
+                        expect(aggregatorObject.formats).toEqual(['####', '#,###']);
+                    });
+
+                    it('Value should be a sum of records when server calculation disabled', () => {
+                        highchartsRenderer.useTotalsCalculation = false;
+                        aggregatorObject.push({Profit: 10});
+                        aggregatorObject.push({Profit: 20});
+                        expect(aggregatorObject.sum).toEqual(30);
+                    });
+
+                    it('Value should be a last record value when server calculation enabled', () => {
+                        highchartsRenderer.useTotalsCalculation = true;
+                        aggregatorObject.push({Profit: 10});
+                        aggregatorObject.push({Profit: 20});
+                        expect(aggregatorObject.sum).toEqual(20);
+                    });
+
+                    it('Widget values format must be redefined if row key should be percentage', () => {
+                        const options = {
+                            comboOptions: {
+                                secondaryAxisSettings: {
+                                    is_percentage: true
+                                },
+                                seriesOptions: [{series: 'Region', secondaryAxis: true}]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region'], '');
+                        aggregatorObject.push({Profit: 20, Region: 'Central'});
+                        expect(aggregatorObject.widget_values_format).toEqual('#,###%');
+                    });
+
+                    it('Value must be ignored if calculated totals disabled', () => {
+                        const options = {
+                            chartOptions: {
+                                table_options: {
+                                    eliminate_calc_totals: true
+                                }
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, false, options, calculated_info);
+                        aggregatorObject = aggregator({colAttrs: [], rowAttrs: []}, ['Region average'], '');
+                        aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
+                        expect(aggregatorObject.ignoreValue).toBe(true);
+                    });
+                });
+
+                describe('Value method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return null if ignore', () => {
+                        aggregatorObject.ignoreValue = true;
+                        expect(aggregatorObject.value()).toBe(null);
+                    });
+
+                    it('Should return value', () => {
+                        aggregatorObject.ignoreValue = false;
+                        expect(aggregatorObject.value()).toBe(0);
+                    });
+                });
+
+                describe('Format method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return empty string if null or undefined', () => {
+                        expect(aggregatorObject.format(null, false)).toBe('');
+                        expect(aggregatorObject.format(undefined, false)).toBe('');
+                    });
+
+                    it('Should return ERROR if has_errors and not only formats', () => {
+                        aggregatorObject.has_errors = true;
+                        expect(aggregatorObject.format(123, false)).toBe('####ERROR####');
+                    });
+
+                    it('Should return General format if there are no widget_values_format', () => {
+                        aggregatorObject.widget_values_format = null;
+                        expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                    });
+
+                    it('Should return widget format if it\'s not calculated value', () => {
+                        aggregatorObject.widget_values_format = '\"$\"#,###.###';
+                        expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                    });
+
+                    it('Should return calculated value format if it\'s calculated value', () => {
+                        aggregator = highchartsRenderer.rhPivotCount(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region average'], '');
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                    });
+                });
+            });
+
+            describe('Uniq values aggregator', () => {
+                let arg;
+                let widget_values_format;
+                let is_graph;
+                let render_options;
+                let calculated_info;
+                let aggregator;
+                let aggregatorObject;
+
+                beforeEach(() => {
+                    arg = ['Country'];
+                    widget_values_format = '"$"####.##';
+                    is_graph = true;
+                    render_options = {};
+                    calculated_info = {
+                        "formats": {
+                            "Average category": null,
+                            "Region average": "####.##%"
+                        },
+                        "associated_fields": {
+                            "Category": [
+                                "Average category"
+                            ],
+                            "Region": [
+                                "Region average"
+                            ]
+                        }
+                    };
+
+                    aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, is_graph, render_options, calculated_info);
+                    aggregatorObject = aggregator({}, '', '');
+                });
+
+                it('Aggregation object structure', () => {
+                    expect(aggregatorObject.uniq).toEqual([]);
+                    expect(aggregatorObject.ignoreValue).toBe(false);
+                    expect(aggregatorObject.formated_values).toEqual([]);
+                    expect(aggregatorObject.widget_values_format).toBe(widget_values_format);
+                    expect(aggregatorObject.calculated_formats).toBe(calculated_info.formats);
+                    expect(aggregatorObject.numInputs).toBe(0);
+                    expect(typeof aggregatorObject.push).toBe('function');
+                    expect(typeof aggregatorObject.value).toBe('function');
+                    expect(typeof aggregatorObject.format).toBe('function');
+                });
+
+                it('numInputs should be 1 if there are no argument', () => {
+                    const agg = highchartsRenderer.rhPivotAggregatorUniqValues([null], widget_values_format, is_graph, render_options, calculated_info);
+                    const aggObject = agg({}, '', '');
+                    expect(aggObject.numInputs).toBe(1);
+                });
+
+                describe('Push method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Sum should be empty if value is not array', () => {
+                        expect(aggregatorObject.push({Country: ''})).toBe(0);
+                    });
+
+                    it('Uniq values from different records without formats', () => {
+                        aggregatorObject.push({Country: ['Poland', 'USA']});
+                        aggregatorObject.push({Country: ['USA', 'UK']});
+                        expect(aggregatorObject.formated_values).toEqual(['Poland', 'USA', 'UK']);
+                    });
+
+                    it('Value format must applied to value if values_formats match in record', () => {
+                        aggregatorObject.push({
+                            Country: [123.123, 456.456, 789.789],
+                            values_formats: [{value: 123.123, data_type: 'n', format: '\'$\'####.##'}]
+                        });
+                        expect(aggregatorObject.formated_values).toEqual(['$123.12', 456.456, 789.789]);
+                    });
+
+                    // it('Value should be a sum of records when server calculation disabled', () => {
+                    //     highchartsRenderer.useTotalsCalculation = false;
+                    //     aggregatorObject.push({Profit: 10});
+                    //     aggregatorObject.push({Profit: 20});
+                    //     expect(aggregatorObject.sum).toEqual(30);
+                    // });
+
+                    it('Value must be ignored if calculated totals disabled', () => {
+                        const options = {
+                            chartOptions: {
+                                table_options: {
+                                    eliminate_calc_totals: true
+                                }
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, false, options, calculated_info);
+                        aggregatorObject = aggregator({colAttrs: [], rowAttrs: []}, ['Region average'], '');
+                        aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
+                        expect(aggregatorObject.ignoreValue).toBe(true);
+                    });
+                });
+
+                describe('Value method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return null if ignore', () => {
+                        aggregatorObject.ignoreValue = true;
+                        expect(aggregatorObject.value()).toBe(null);
+                    });
+
+                    it('Should return length if graph', () => {
+                        aggregatorObject.uniq = ['val1', 'val2'];
+                        expect(aggregatorObject.value()).toBe(2);
+                    });
+
+                    it('Should return value if table', () => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, false, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                        aggregatorObject.uniq = ['val1', 'val2'];
+                        expect(aggregatorObject.value()).toBe('val1<br>val2');
+                    });
+                });
+
+                describe('Format method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return empty string if null or undefined', () => {
+                        expect(aggregatorObject.format(null, false)).toBe('');
+                        expect(aggregatorObject.format(undefined, false)).toBe('');
+                    });
+
+                    it('Should return widget format if it\'s graph', () => {
+                        aggregatorObject.widget_values_format = '\"$\"#,###.###';
+                        expect(aggregatorObject.format(2, false)).toBe('$2.0');
+                    });
+
+                    it('Should return widget format if it\'s only_formats', () => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, false, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                        aggregatorObject.widget_values_format = '\"$\"#,###.###';
+                        expect(aggregatorObject.format(2, true)).toBe('$2.0');
+                    });
+
+                    it('Should return uniq values if it\'s table and not only_formats', () => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorUniqValues(arg, widget_values_format, false, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                        aggregatorObject.formated_values = ['val1', 'val2'];
+                        expect(aggregatorObject.format(aggregatorObject.formated_values, false)).toBe('val1<br>val2');
+                    });
+                });
+            });
+
+            describe('Average aggregator', () => {
+                let arg;
+                let widget_values_format;
+                let is_graph;
+                let render_options;
+                let calculated_info;
+                let aggregator;
+                let aggregatorObject;
+
+                beforeEach(() => {
+                    arg = ['Profit'];
+                    widget_values_format = '"$"####.##';
+                    is_graph = true;
+                    render_options = {};
+                    calculated_info = {
+                        "formats": {
+                            "Average category": null,
+                            "Region average": "####.##%"
+                        },
+                        "associated_fields": {
+                            "Category": [
+                                "Average category"
+                            ],
+                            "Region": [
+                                "Region average"
+                            ]
+                        }
+                    };
+
+                    aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, render_options, calculated_info);
+                    aggregatorObject = aggregator({}, '', '');
+                });
+
+                it('Aggregation object structure', () => {
+                    expect(aggregatorObject.sum).toBe(0);
+                    expect(aggregatorObject.len).toBe(0);
+                    expect(aggregatorObject.ignoreValue).toBe(false);
+                    expect(aggregatorObject.data_types).toEqual([]);
+                    expect(aggregatorObject.formats).toEqual([]);
+                    expect(aggregatorObject.has_errors).toBe(false);
+                    expect(aggregatorObject.widget_values_format).toBe(widget_values_format);
+                    expect(aggregatorObject.calculated_formats).toBe(calculated_info.formats);
+                    expect(aggregatorObject.isChangeable).toBe(false);
+                    expect(aggregatorObject.numInputs).toBe(0);
+                    expect(typeof aggregatorObject.push).toBe('function');
+                    expect(typeof aggregatorObject.value).toBe('function');
+                    expect(typeof aggregatorObject.format).toBe('function');
+                });
+
+                it('numInputs should be 1 if there are no argument', () => {
+                    const agg = highchartsRenderer.rhPivotAggregatorAverage([null], widget_values_format, is_graph, render_options, calculated_info);
+                    const aggObject = agg({}, '', '');
+                    expect(aggObject.numInputs).toBe(1);
+                });
+
+                describe('Push method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should be error if wrong data_types', () => {
+                        aggregatorObject.push({
+                            data_types: ['d', '1']
+                        });
+                        expect(aggregatorObject.has_errors).toBe(true);
+                    });
+
+                    it('Sum shouldn\'t be changed if value is string', () => {
+                        aggregatorObject.push({Profit: 'incorrectValue'});
+                        expect(aggregatorObject.sum).toBe(0);
+                    });
+
+                    it('Data types must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, data_types: ['1', '1', '2']});
+                        expect(aggregatorObject.data_types).toEqual(['1', '2']);
+                    });
+
+                    it('Formats must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
+                        expect(aggregatorObject.formats).toEqual(['####', '#,###']);
+                    });
+
+                    it('Value should be a sum of records when server calculation disabled', () => {
+                        highchartsRenderer.useTotalsCalculation = false;
+                        aggregatorObject.push({Profit: 10});
+                        aggregatorObject.push({Profit: 20});
+                        expect(aggregatorObject.sum).toEqual(30);
+                        expect(aggregatorObject.len).toEqual(2);
+                    });
+
+                    it('Value should be a last record value when server calculation enabled', () => {
+                        highchartsRenderer.useTotalsCalculation = true;
+                        aggregatorObject.push({Profit: 20});
+                        aggregatorObject.push({Profit: 10});
+                        expect(aggregatorObject.sum).toEqual(10);
+                        expect(aggregatorObject.len).toEqual(2);
+                    });
+
+                    it('Widget values format must be redefined if row key should be percentage', () => {
+                        const options = {
+                            comboOptions: {
+                                secondaryAxisSettings: {
+                                    is_percentage: true
+                                },
+                                seriesOptions: [{series: 'Region', secondaryAxis: true}]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region'], '');
+                        aggregatorObject.push({Profit: 20, Region: 'Central'});
+                        expect(aggregatorObject.widget_values_format).toEqual('#,###%');
+                    });
+
+                    it('Value must be ignored if calculated totals disabled', () => {
+                        const options = {
+                            chartOptions: {
+                                table_options: {
+                                    eliminate_calc_totals: true
+                                }
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, false, options, calculated_info);
+                        aggregatorObject = aggregator({colAttrs: [], rowAttrs: []}, ['Region average'], '');
+                        aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
+                        expect(aggregatorObject.ignoreValue).toBe(true);
+                    });
+                });
+
+                describe('Value method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                        aggregatorObject.sum = 20;
+                        aggregatorObject.len = 4;
+                    });
+
+                    it('Should return null if ignore', () => {
+                        aggregatorObject.ignoreValue = true;
+                        expect(aggregatorObject.value()).toBe(null);
+                    });
+
+                    it('Should return sum if server calculation enabled', () => {
+                        highchartsRenderer.useTotalsCalculation = true;
+                        aggregatorObject.ignoreValue = false;
+                        expect(aggregatorObject.value()).toBe(20);
+                    });
+
+                    it('Should return average if server calculation disabled', () => {
+                        highchartsRenderer.useTotalsCalculation = false;
+                        aggregatorObject.ignoreValue = false;
+                        expect(aggregatorObject.value()).toBe(5);
+                    });
+                });
+
+                describe('Format method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return empty string if null or undefined', () => {
+                        expect(aggregatorObject.format(null, false)).toBe('');
+                        expect(aggregatorObject.format(undefined, false)).toBe('');
+                    });
+
+                    it('Should return ERROR if has_errors and not only formats', () => {
+                        aggregatorObject.has_errors = true;
+                        expect(aggregatorObject.format(123, false)).toBe('####ERROR####');
+                    });
+
+                    it('Should return General format if there are no widget_values_format', () => {
+                        aggregatorObject.widget_values_format = null;
+                        expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                    });
+
+                    it('Should return widget format if it\'s not calculated value', () => {
+                        aggregatorObject.widget_values_format = '\"$\"#,###.###';
+                        expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                    });
+
+                    it('Should return calculated value format if it\'s calculated value', () => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorAverage(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region average'], '');
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                    });
+                });
+            });
+
+            describe('Min aggregator', () => {
+                let arg;
+                let widget_values_format;
+                let is_graph;
+                let render_options;
+                let calculated_info;
+                let aggregator;
+                let aggregatorObject;
+
+                beforeEach(() => {
+                    arg = ['Profit'];
+                    widget_values_format = '"$"####.##';
+                    is_graph = true;
+                    render_options = {};
+                    calculated_info = {
+                        "formats": {
+                            "Average category": null,
+                            "Region average": "####.##%"
+                        },
+                        "associated_fields": {
+                            "Category": [
+                                "Average category"
+                            ],
+                            "Region": [
+                                "Region average"
+                            ]
+                        }
+                    };
+
+                    aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, render_options, calculated_info);
+                    aggregatorObject = aggregator({}, '', '');
+                });
+
+                it('Aggregation object structure', () => {
+                    expect(aggregatorObject.val).toBe(null);
+                    expect(aggregatorObject.ignoreValue).toBe(false);
+                    expect(aggregatorObject.data_types).toEqual([]);
+                    expect(aggregatorObject.formats).toEqual([]);
+                    expect(aggregatorObject.has_errors).toBe(false);
+                    expect(aggregatorObject.widget_values_format).toBe(widget_values_format);
+                    expect(aggregatorObject.calculated_formats).toBe(calculated_info.formats);
+                    expect(aggregatorObject.isChangeable).toBe(false);
+                    expect(aggregatorObject.numInputs).toBe(0);
+                    expect(typeof aggregatorObject.push).toBe('function');
+                    expect(typeof aggregatorObject.value).toBe('function');
+                    expect(typeof aggregatorObject.format).toBe('function');
+                });
+
+                it('numInputs should be 1 if there are no argument', () => {
+                    const agg = highchartsRenderer.rhPivotAggregatorMin([null], widget_values_format, is_graph, render_options, calculated_info);
+                    const aggObject = agg({}, '', '');
+                    expect(aggObject.numInputs).toBe(1);
+                });
+
+                describe('Push method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should be error if wrong data_types', () => {
+                        aggregatorObject.push({
+                            data_types: ['d', '1']
+                        });
+                        expect(aggregatorObject.has_errors).toBe(true);
+                    });
+
+                    it('Sum shouldn\'t be changed if value is string', () => {
+                        aggregatorObject.push({Profit: 'incorrectValue'});
+                        expect(aggregatorObject.val).toBe(null);
+                    });
+
+                    it('Data types must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, data_types: ['1', '1', '2']});
+                        expect(aggregatorObject.data_types).toEqual(['1', '2']);
+                    });
+
+                    it('Formats must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
+                        expect(aggregatorObject.formats).toEqual(['####', '#,###']);
+                    });
+
+                    it('Value should be a min of records when server calculation disabled', () => {
+                        highchartsRenderer.useTotalsCalculation = false;
+                        aggregatorObject.push({Profit: 10});
+                        aggregatorObject.push({Profit: 20});
+                        expect(aggregatorObject.val).toEqual(10);
+                    });
+
+                    it('Value should be a last record value when server calculation enabled', () => {
+                        highchartsRenderer.useTotalsCalculation = true;
+                        aggregatorObject.push({Profit: 10});
+                        aggregatorObject.push({Profit: 20});
+                        expect(aggregatorObject.val).toEqual(20);
+                    });
+
+                    it('Widget values format must be redefined if row key should be percentage', () => {
+                        const options = {
+                            comboOptions: {
+                                secondaryAxisSettings: {
+                                    is_percentage: true
+                                },
+                                seriesOptions: [{series: 'Region', secondaryAxis: true}]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region'], '');
+                        aggregatorObject.push({Profit: 20, Region: 'Central'});
+                        expect(aggregatorObject.widget_values_format).toEqual('#,###%');
+                    });
+
+                    it('Value must be ignored if calculated totals disabled', () => {
+                        const options = {
+                            chartOptions: {
+                                table_options: {
+                                    eliminate_calc_totals: true
+                                }
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, false, options, calculated_info);
+                        aggregatorObject = aggregator({colAttrs: [], rowAttrs: []}, ['Region average'], '');
+                        aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
+                        expect(aggregatorObject.ignoreValue).toBe(true);
+                    });
+                });
+
+                describe('Value method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return null if ignore', () => {
+                        aggregatorObject.ignoreValue = true;
+                        expect(aggregatorObject.value()).toBe(null);
+                    });
+
+                    it('Should return value', () => {
+                        aggregatorObject.ignoreValue = false;
+                        aggregatorObject.val = 10;
+                        expect(aggregatorObject.value()).toBe(10);
+                    });
+                });
+
+                describe('Format method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return empty string if null or undefined', () => {
+                        expect(aggregatorObject.format(null, false)).toBe('');
+                        expect(aggregatorObject.format(undefined, false)).toBe('');
+                    });
+
+                    it('Should return ERROR if has_errors and not only formats', () => {
+                        aggregatorObject.has_errors = true;
+                        expect(aggregatorObject.format(123, false)).toBe('####ERROR####');
+                    });
+
+                    it('Should return General format if there are no widget_values_format', () => {
+                        aggregatorObject.widget_values_format = null;
+                        expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                    });
+
+                    it('Should return widget format if it\'s not calculated value', () => {
+                        aggregatorObject.widget_values_format = '\"$\"#,###.###';
+                        expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                    });
+
+                    it('Should return calculated value format if it\'s calculated value', () => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMin(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region average'], '');
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                    });
+                });
+            });
+
+            describe('Max aggregator', () => {
+                let arg;
+                let widget_values_format;
+                let is_graph;
+                let render_options;
+                let calculated_info;
+                let aggregator;
+                let aggregatorObject;
+
+                beforeEach(() => {
+                    arg = ['Profit'];
+                    widget_values_format = '"$"####.##';
+                    is_graph = true;
+                    render_options = {};
+                    calculated_info = {
+                        "formats": {
+                            "Average category": null,
+                            "Region average": "####.##%"
+                        },
+                        "associated_fields": {
+                            "Category": [
+                                "Average category"
+                            ],
+                            "Region": [
+                                "Region average"
+                            ]
+                        }
+                    };
+
+                    aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, render_options, calculated_info);
+                    aggregatorObject = aggregator({}, '', '');
+                });
+
+                it('Aggregation object structure', () => {
+                    expect(aggregatorObject.val).toBe(null);
+                    expect(aggregatorObject.ignoreValue).toBe(false);
+                    expect(aggregatorObject.data_types).toEqual([]);
+                    expect(aggregatorObject.formats).toEqual([]);
+                    expect(aggregatorObject.has_errors).toBe(false);
+                    expect(aggregatorObject.widget_values_format).toBe(widget_values_format);
+                    expect(aggregatorObject.calculated_formats).toBe(calculated_info.formats);
+                    expect(aggregatorObject.isChangeable).toBe(false);
+                    expect(aggregatorObject.numInputs).toBe(0);
+                    expect(typeof aggregatorObject.push).toBe('function');
+                    expect(typeof aggregatorObject.value).toBe('function');
+                    expect(typeof aggregatorObject.format).toBe('function');
+                });
+
+                it('numInputs should be 1 if there are no argument', () => {
+                    const agg = highchartsRenderer.rhPivotAggregatorMax([null], widget_values_format, is_graph, render_options, calculated_info);
+                    const aggObject = agg({}, '', '');
+                    expect(aggObject.numInputs).toBe(1);
+                });
+
+                describe('Push method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should be error if wrong data_types', () => {
+                        aggregatorObject.push({
+                            data_types: ['d', '1']
+                        });
+                        expect(aggregatorObject.has_errors).toBe(true);
+                    });
+
+                    it('Sum shouldn\'t be changed if value is string', () => {
+                        aggregatorObject.push({Profit: 'incorrectValue'});
+                        expect(aggregatorObject.val).toBe(null);
+                    });
+
+                    it('Data types must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, data_types: ['1', '1', '2']});
+                        expect(aggregatorObject.data_types).toEqual(['1', '2']);
+                    });
+
+                    it('Formats must be filled and uniq', () => {
+                        aggregatorObject.push({Profit: 123, formats: ['####', '####', '#,###']});
+                        expect(aggregatorObject.formats).toEqual(['####', '#,###']);
+                    });
+
+                    it('Value should be a min of records when server calculation disabled', () => {
+                        highchartsRenderer.useTotalsCalculation = false;
+                        aggregatorObject.push({Profit: 20});
+                        aggregatorObject.push({Profit: 10});
+                        expect(aggregatorObject.val).toEqual(20);
+                    });
+
+                    it('Value should be a last record value when server calculation enabled', () => {
+                        highchartsRenderer.useTotalsCalculation = true;
+                        aggregatorObject.push({Profit: 20});
+                        aggregatorObject.push({Profit: 10});
+                        expect(aggregatorObject.val).toEqual(10);
+                    });
+
+                    it('Widget values format must be redefined if row key should be percentage', () => {
+                        const options = {
+                            comboOptions: {
+                                secondaryAxisSettings: {
+                                    is_percentage: true
+                                },
+                                seriesOptions: [{series: 'Region', secondaryAxis: true}]
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region'], '');
+                        aggregatorObject.push({Profit: 20, Region: 'Central'});
+                        expect(aggregatorObject.widget_values_format).toEqual('#,###%');
+                    });
+
+                    it('Value must be ignored if calculated totals disabled', () => {
+                        const options = {
+                            chartOptions: {
+                                table_options: {
+                                    eliminate_calc_totals: true
+                                }
+                            }
+                        }
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, false, options, calculated_info);
+                        aggregatorObject = aggregator({colAttrs: [], rowAttrs: []}, ['Region average'], '');
+                        aggregatorObject.push({Profit: 20, 'Region average': 'Central', Region: 'Region average'});
+                        expect(aggregatorObject.ignoreValue).toBe(true);
+                    });
+                });
+
+                describe('Value method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return null if ignore', () => {
+                        aggregatorObject.ignoreValue = true;
+                        expect(aggregatorObject.value()).toBe(null);
+                    });
+
+                    it('Should return value', () => {
+                        aggregatorObject.ignoreValue = false;
+                        aggregatorObject.val = 10;
+                        expect(aggregatorObject.value()).toBe(10);
+                    });
+                });
+
+                describe('Format method', () => {
+                    beforeEach(() => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, '', '');
+                    });
+
+                    it('Should return empty string if null or undefined', () => {
+                        expect(aggregatorObject.format(null, false)).toBe('');
+                        expect(aggregatorObject.format(undefined, false)).toBe('');
+                    });
+
+                    it('Should return ERROR if has_errors and not only formats', () => {
+                        aggregatorObject.has_errors = true;
+                        expect(aggregatorObject.format(123, false)).toBe('####ERROR####');
+                    });
+
+                    it('Should return General format if there are no widget_values_format', () => {
+                        aggregatorObject.widget_values_format = null;
+                        expect(aggregatorObject.format(123.4567, false)).toBe('123.46');
+                    });
+
+                    it('Should return widget format if it\'s not calculated value', () => {
+                        aggregatorObject.widget_values_format = '\"$\"#,###.###';
+                        expect(aggregatorObject.format(1123.4567, false)).toBe('$1,123.457');
+                    });
+
+                    it('Should return calculated value format if it\'s calculated value', () => {
+                        aggregator = highchartsRenderer.rhPivotAggregatorMax(arg, widget_values_format, is_graph, render_options, calculated_info);
+                        aggregatorObject = aggregator({}, ['Region average'], '');
+                        expect(aggregatorObject.format(1123.45678, false)).toBe('112345.68%');
+                    });
+                });
+            });
+        });
+    });
+
+
+    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);
+        });
+    });
 });