@datarailsshared/dr_renderer 1.2.463 → 1.3.2

package/tests/highcharts_renderer.test.js

@@ -917,7 +917,7 @@ describe('highcharts_renderer', () => {
 
         it('should return filter icon for matching axis', () => {
             const axis = 'row'
-            const expected = '<i class="fa fa-filter"></i>'
+            const expected = '<i class="dr-icon-filter-old"></i>'
             const result = highchartsRenderer.getIconsForTotalOptions(options, axis)
             expect(result).toEqual(expected)
         });
@@ -6811,6 +6811,7 @@ describe('highcharts_renderer', () => {
                         formatter: expect.any(Function),
                     },
                     color: '#ff0202',
+                    connectNulls: false,
                     type: 'area'
                 },
                 {data: [
@@ -6846,6 +6847,7 @@ describe('highcharts_renderer', () => {
                         enabled: true,
                         formatter: expect.any(Function),
                     },
+                    connectNulls: false,
                     color: '#b3060e',
                     type: 'line'
                 }
@@ -7082,7 +7084,11 @@ describe('highcharts_renderer', () => {
                 "#70000a"
             ];
             opts = {};
-            chartOptions = {};
+            chartOptions = {
+                chart: {
+                    type: '',
+                }
+            };
             pivotDataMock = {
                 getAggregator: (rows, cols) => {
                     let aggregator = highchartsRenderer.rhPivotAggregatorSum([''], format, true, {}, {});
@@ -8349,166 +8355,6 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe('Function ptCreateGaugeSeries', () => {
-
-        const pivotDataMock = {
-            getAggregator: () => ({
-                value: () => 1000,
-                format: (val) => `formatted(${ val })`,
-            })
-        }
-
-        beforeEach(() => {
-            spyOn(highchartsRenderer, 'getSingleValueAgg').and.callFake(
-                (_gaugeOpts, aggfunc, base) => ({ aggfunc, base })
-            );
-            spyOn(highchartsRenderer, 'getDataLabelsStyle').and.returnValue('test_style');
-            spyOn(highchartsRenderer, 'getDataLabelsOptions').and.callFake(
-                (_gaugeOpts, seriesElement) => ({...seriesElement, additionalOptions: 'test_additional_opts'})
-            );
-        });
-
-        describe('with two calc values', () => {
-
-            const mockGaugeOpts = {
-                label: {
-                    overlap: true,
-                    show: false,
-                }
-            };
-
-            beforeEach(() => {
-                spyOn(highchartsRenderer, 'ptCreateBasicLineSeries').and.returnValue([
-                    {
-                        data: [39],
-                        initialName: "Test Calc",
-                        name: "Test Calc"
-                    },
-                    {
-                        data: [21],
-                        initialName: "Test Calc 2",
-                        name: "Test Calc 2"
-                    }
-                ]);
-            });
-
-            it('should create gauge series, two calc values, isSolidGauge = false, labels disabled', () => {
-                expect(highchartsRenderer.ptCreateGaugeSeries(pivotDataMock, {}, {}, mockGaugeOpts, false)).toEqual([
-                    {
-                        additionalOptions: 'test_additional_opts',
-                        colorByPoint: true,
-                        data: [60],
-                        dataLabels: {
-                            allowOverlap: true,
-                            enabled: false,
-                            format: '<div style="text-align:center"><span style="font-size:15px;color:black">formatted(60)</span><br/><span style="font-size:12px;color:silver"></span></div>',
-                            style: 'test_style',
-                        },
-                        name: '',
-                    },
-                ]);
-            });
-
-            it('should create gauge series, two calc values, isSolidGauge = false, labels enabled', () => {
-                const gaugeOpts = lodash.cloneDeep(mockGaugeOpts);
-                gaugeOpts.label.show = true;
-                expect(highchartsRenderer.ptCreateGaugeSeries(pivotDataMock, {}, {}, gaugeOpts, false)).toEqual([
-                    {
-                        additionalOptions: 'test_additional_opts',
-                        colorByPoint: true,
-                        data: [60],
-                        dataLabels: {
-                            allowOverlap: true,
-                            enabled: true,
-                            format: '<div style="text-align:center"><span style="font-size:15px;color:black">formatted(60)</span><br/><span style="font-size:12px;color:silver"></span></div>',
-                            style: 'test_style',
-                        },
-                        name: '',
-                    },
-                ]);
-            });
-    
-            it('should create gauge series, two calc values, isSolidGauge = true', () => {
-                expect(highchartsRenderer.ptCreateGaugeSeries(pivotDataMock, {}, {}, mockGaugeOpts, true)).toEqual([
-                    {
-                        additionalOptions: 'test_additional_opts',
-                        colorByPoint: true,
-                        data: [60],
-                        dataLabels: {
-                            allowOverlap: true,
-                            enabled: true,
-                            format: '<div style="text-align:center"><span style="font-size:25px;color:black">formatted(60)</span><br/><span style="font-size:12px;color:silver"></span></div>',
-                            style: 'test_style',
-                        },
-                        name: '',
-                    },
-                ]);
-            });
-        });
-
-        it('should create gauge series, one calc value', () => {
-            const mockGaugeOpts = {
-                label: {
-                    overlap: true,
-                    show: false,
-                }
-            };
-
-            spyOn(highchartsRenderer, 'ptCreateBasicLineSeries').and.returnValue([
-                {
-                    data: [39],
-                    initialName: "Test Calc",
-                    name: "Test Calc"
-                },
-            ]);
-
-            expect(highchartsRenderer.ptCreateGaugeSeries(pivotDataMock, {}, {}, mockGaugeOpts, false)).toEqual([
-                {
-                    additionalOptions: 'test_additional_opts',
-                    colorByPoint: true,
-                    data: [39],
-                    dataLabels: {
-                        allowOverlap: true,
-                        enabled: false,
-                        format: '<div style="text-align:center"><span style="font-size:15px;color:black">formatted(39)</span><br/><span style="font-size:12px;color:silver"></span></div>',
-                        style: 'test_style',
-                    },
-                    name: '',
-                },
-            ]);
-        });
-
-        it('should create gauge series, no calculated, one value field', () => {
-            const mockGaugeOpts = {
-                label: {
-                    overlap: true,
-                    show: false,
-                }
-            };
-
-            spyOn(highchartsRenderer, 'ptCreateBasicLineSeries').and.returnValue([
-                {
-                    data: [32605]
-                },
-            ]);
-
-            expect(highchartsRenderer.ptCreateGaugeSeries(pivotDataMock, {}, {}, mockGaugeOpts, false)).toEqual([
-                {
-                    additionalOptions: 'test_additional_opts',
-                    colorByPoint: true,
-                    data: [32605],
-                    dataLabels: {
-                        allowOverlap: true,
-                        enabled: false,
-                        format: '<div style="text-align:center"><span style="font-size:15px;color:black">formatted(32605)</span><br/><span style="font-size:12px;color:silver"></span></div>',
-                        style: 'test_style',
-                    },
-                    name: '',
-                },
-            ]);
-        });
-    });
-
     describe('highchartsRenderer.ptRenderPieWithDrillDown', () => {
         beforeEach(() => {
             jest.spyOn(highchartsRenderer, 'ptCreateSeriesToDrillDownChart')
@@ -8869,241 +8715,6 @@ describe('highcharts_renderer', () => {
         });
     });
 
-    describe('Function ptRenderGauge', () => {
-
-        const pivotDataMock = {
-            getColKeys: () => [[1], [2], [3]],
-        };
-
-        const commonExpectedOptions = {
-            chart: { animation: true, type: 'gauge' },
-            credits: { enabled: false },
-            pane: {
-                background: [
-                    {
-                        backgroundColor: {
-                            linearGradient: { x1: 0, x2: 0, y1: 0, y2: 1 },
-                            stops: [
-                                [0, '#fff'],
-                                [1, '#333'],
-                            ],
-                        },
-                        borderWidth: 0,
-                        outerRadius: '109%',
-                    },
-                    {
-                        backgroundColor: {
-                            linearGradient: { x1: 0, x2: 0, y1: 0, y2: 1 },
-                            stops: [
-                                [0, '#333'],
-                                [1, '#fff'],
-                            ],
-                        },
-                        borderWidth: 1,
-                        outerRadius: '107%',
-                    },
-                    {},
-                    { backgroundColor: '#DDD', borderWidth: 0, innerRadius: '103%', outerRadius: '105%' },
-                ],
-                endAngle: 150,
-                startAngle: -150,
-            },
-            plotOptions: {
-                series: { animation: true },
-                solidgauge: {
-                    additionalOptions: 'test_additional_opts',
-                    allowPointSelect: true,
-                    cursor: 'pointer',
-                    dataLabels: { allowOverlap: true, borderWidth: 0, style: 'test_style', useHTML: true, y: 5 },
-                },
-            },
-            series: 'test_gauge_series',
-            subtitle: 'test_subtitle',
-            title: 'test_title',
-            xAxis: { categories: ['formatted(1)', 'formatted(2)', 'formatted(3)'] },
-        };
-
-        const gaugeDefaultChartOptions = {
-            label: {
-                overlap: true,
-                show: false,
-            },
-            range: {
-                min: 0,
-                max: 12345,
-                low: 100,
-                medium: 200,
-                high: 300,
-            },
-        };
-
-        const chartOptionsInOpts = {
-            label: {
-                overlap: false,
-                show: true,
-            },
-            range: {
-                min: 1,
-                max: 234567,
-                low: 500,
-                medium: 800,
-                high: 1000,
-            },
-        };
-
-        beforeEach(() => {
-            spyOn(highchartsRenderer, 'getDefaultValueForChart').and.returnValue(gaugeDefaultChartOptions);
-            spyOn(highchartsRenderer, 'getDataLabelsStyle').and.returnValue('test_style');
-            spyOn(highchartsRenderer, 'getDataLabelsOptions').and.callFake(
-                (_gaugeOpts, seriesElement) => ({...seriesElement, additionalOptions: 'test_additional_opts'})
-            );
-            spyOn(highchartsRenderer, 'getFormattedColKeys').and.callFake(
-                (pivotData, _keys) => pivotData.getColKeys().map(key => `formatted(${ key })`)
-            );
-            spyOn(highchartsRenderer, 'ptCreateGaugeSeries').and.returnValue('test_gauge_series');
-            spyOn(highchartsRenderer, 'setTitleAndSubTitle').and.callFake((chartOptions, _opts, _gaugeopts) => {
-                chartOptions.title = 'test_title';
-                chartOptions.subtitle = 'test_subtitle';
-            });
-            spyOn(highchartsRenderer, 'ptCreateElementAndDraw').and.returnValue();
-        });
-
-        it('should call ptCreateElementAndDraw with proper options: no chartOptions passed in opts', () => {
-            const optsMock = {
-                testOptsField: 'test_opts_field_value',
-            };
-
-            highchartsRenderer.ptRenderGauge(pivotDataMock, lodash.cloneDeep(optsMock));
-
-            const expectedChartOptions = {
-                ...commonExpectedOptions,
-                yAxis: {
-                    labels: { rotation: 'auto', step: 2 },
-                    max: 12345,
-                    min: 0,
-                    minorTickColor: '#666',
-                    minorTickInterval: 'auto',
-                    minorTickLength: 10,
-                    minorTickPosition: 'inside',
-                    minorTickWidth: 1,
-                    plotBands: [
-                        { color: '#55BF3B', from: 0, to: 12345 },
-                        { color: '#DDDF0D', from: 12345, to: 24690 },
-                        { color: '#DF5353', from: 24690, to: 12345 },
-                    ],
-                    tickColor: '#666',
-                    tickLength: 10,
-                    tickPixelInterval: 30,
-                    tickPosition: 'inside',
-                    tickWidth: 2,
-                    title: { text: '' },
-                },
-            };
-
-            expect(highchartsRenderer.ptCreateGaugeSeries)
-                .toHaveBeenCalledWith(pivotDataMock, optsMock, expectedChartOptions, gaugeDefaultChartOptions, false);
-            expect(highchartsRenderer.ptCreateElementAndDraw).toHaveBeenCalledWith(expectedChartOptions, optsMock);
-        });
-
-        it('should call ptCreateElementAndDraw with proper options: chartOptions passed in opts', () => {
-            const optsMock = {
-                testOptsField: 'test_opts_field_value',
-                chartOptions: chartOptionsInOpts,
-            };
-
-            highchartsRenderer.ptRenderGauge(pivotDataMock, lodash.cloneDeep(optsMock));
-
-            const expectedChartOptions = {
-                ...commonExpectedOptions,
-                yAxis: {
-                    labels: { rotation: 'auto', step: 2 },
-                    max: 234567,
-                    min: 0,
-                    minorTickColor: '#666',
-                    minorTickInterval: 'auto',
-                    minorTickLength: 10,
-                    minorTickPosition: 'inside',
-                    minorTickWidth: 1,
-                    plotBands: [
-                        { color: '#55BF3B', from: 0, to: 1172835 },
-                        { color: '#DDDF0D', from: 1172835, to: 1876536 },
-                        { color: '#DF5353', from: 1876536, to: 234567 },
-                    ],
-                    tickColor: '#666',
-                    tickLength: 10,
-                    tickPixelInterval: 30,
-                    tickPosition: 'inside',
-                    tickWidth: 2,
-                    title: { text: '' },
-                },
-            };
-            lodash.set(expectedChartOptions, 'plotOptions.solidgauge.dataLabels.allowOverlap', false);
-
-            expect(highchartsRenderer.ptCreateGaugeSeries)
-                .toHaveBeenCalledWith(pivotDataMock, optsMock, expectedChartOptions, optsMock.chartOptions, false);
-            expect(highchartsRenderer.ptCreateElementAndDraw).toHaveBeenCalledWith(expectedChartOptions, optsMock);
-        });
-
-        it('should call ptCreateElementAndDraw with proper options: for solid gauge', () => {
-            const optsMock = {
-                testOptsField: 'test_opts_field_value',
-                chartOptions: chartOptionsInOpts,
-            };
-
-            highchartsRenderer.ptRenderGauge(pivotDataMock, lodash.cloneDeep(optsMock), true);
-
-            const expectedChartOptions = {
-                chart: { animation: true, type: 'solidgauge' },
-                credits: { enabled: false },
-                pane: {
-                    background: { backgroundColor: '#fff', innerRadius: '60%', outerRadius: '100%', shape: 'arc' },
-                    center: ['50%', '85%'],
-                    endAngle: 90,
-                    size: '140%',
-                    startAngle: -90,
-                },
-                plotOptions: {
-                    series: { animation: true },
-                    solidgauge: {
-                        additionalOptions: 'test_additional_opts',
-                        allowPointSelect: true,
-                        cursor: 'pointer',
-                        dataLabels: { allowOverlap: false, borderWidth: 0, style: 'test_style', useHTML: true, y: 5 },
-                    },
-                },
-                series: 'test_gauge_series',
-                subtitle: 'test_subtitle',
-                title: 'test_title',
-                xAxis: { categories: ['formatted(1)', 'formatted(2)', 'formatted(3)'] },
-                yAxis: {
-                    labels: { y: 16 },
-                    lineWidth: 0,
-                    max: 234567,
-                    min: 0,
-                    minorTickInterval: null,
-                    stops: [
-                        [5, '#55BF3B'],
-                        [8, '#DDDF0D'],
-                        [10, '#DF5353'],
-                    ],
-                    tickPixelInterval: 400,
-                    tickWidth: 0,
-                },
-            };
-            lodash.set(expectedChartOptions, 'plotOptions.solidgauge.dataLabels.allowOverlap', false);
-
-            expect(highchartsRenderer.ptCreateGaugeSeries)
-                .toHaveBeenCalledWith(pivotDataMock, optsMock, expectedChartOptions, optsMock.chartOptions, true);
-            expect(highchartsRenderer.ptCreateElementAndDraw).toHaveBeenCalledWith(expectedChartOptions, optsMock);
-        });
-    });
-
-    it('ptRenderSolidGauge should call ptRenderGauge with isSolidGauge = true', () => {
-        spyOn(highchartsRenderer, 'ptRenderGauge').and.returnValue();
-        highchartsRenderer.ptRenderSolidGauge('mock_pivot_data', 'mock_opts');
-        expect(highchartsRenderer.ptRenderGauge).toHaveBeenCalledWith('mock_pivot_data', 'mock_opts', true);
-    });
-
     describe("Function ptCreateWaterfallBreakdownSeries", () => {
         const format = null;
         const additionalOptionsMock = { testOption: 'test additional option 1' }