@datarailsshared/dr_renderer 1.2.294 → 1.2.295

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 tables from './mock/tables.json';
 import initPivotTable from "../src/pivottable";
 import initDRPivotTable from "../src/dr_pivottable";
 
@@ -394,4 +395,1935 @@ 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('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%');
+                    });
+                });
+            });
+        });
+    });
 });