energylink/public/app/plugins/panel/table/specs/transformers.jest.ts

import {transformers, transformDataToTable} from '../transformers';

describe('when transforming time series table', () => {
  var table;

  describe('given 2 time series', () => {
    var time = new Date().getTime();
    var timeSeries = [
      {
        target: 'series1',
        datapoints: [[12.12, time], [14.44, time+1]],
      },
      {
        target: 'series2',
        datapoints: [[16.12, time]],
      }
    ];

    describe('timeseries_to_rows', () => {
      var panel = {
        transform: 'timeseries_to_rows',
        sort: {col: 0, desc: true},
      };

      beforeEach(() => {
        table = transformDataToTable(timeSeries, panel);
      });

      it('should return 3 rows', () => {
        expect(table.rows.length).toBe(3);
        expect(table.rows[0][1]).toBe('series1');
        expect(table.rows[1][1]).toBe('series1');
        expect(table.rows[2][1]).toBe('series2');
        expect(table.rows[0][2]).toBe(12.12);
      });

      it('should return 3 rows', () => {
        expect(table.columns.length).toBe(3);
        expect(table.columns[0].text).toBe('Time');
        expect(table.columns[1].text).toBe('Metric');
        expect(table.columns[2].text).toBe('Value');
      });
    });

    describe('timeseries_to_columns', () => {
      var panel = {
        transform: 'timeseries_to_columns'
      };

      beforeEach(() => {
        table = transformDataToTable(timeSeries, panel);
      });

      it ('should return 3 columns', () => {
        expect(table.columns.length).toBe(3);
        expect(table.columns[0].text).toBe('Time');
        expect(table.columns[1].text).toBe('series1');
        expect(table.columns[2].text).toBe('series2');
      });

      it ('should return 2 rows', () => {
        expect(table.rows.length).toBe(2);
        expect(table.rows[0][1]).toBe(12.12);
        expect(table.rows[0][2]).toBe(16.12);
      });

      it ('should be undefined when no value for timestamp', () => {
        expect(table.rows[1][2]).toBe(undefined);
      });
    });

    describe('timeseries_aggregations', () => {
      var panel = {
        transform: 'timeseries_aggregations',
        sort: {col: 0, desc: true},
        columns: [{text: 'Max', value: 'max'}, {text: 'Min', value: 'min'}]
      };

      beforeEach(() => {
        table = transformDataToTable(timeSeries, panel);
      });

      it('should return 2 rows', () => {
        expect(table.rows.length).toBe(2);
        expect(table.rows[0][0]).toBe('series1');
        expect(table.rows[0][1]).toBe(14.44);
        expect(table.rows[0][2]).toBe(12.12);
      });

      it('should return 2 columns', () => {
        expect(table.columns.length).toBe(3);
        expect(table.columns[0].text).toBe('Metric');
        expect(table.columns[1].text).toBe('Max');
        expect(table.columns[2].text).toBe('Min');
      });
    });
  });

  describe('table data sets', () => {
    describe('Table', () => {
      const transform = 'table';
      var panel = {
        transform,
      };
      var time = new Date().getTime();

      var nonTableData = [
        {
          type: 'foo',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Value' },
          ],
          rows: [
            [time, 'Label Value 1', 42],
          ],
        }
      ];

      var singleQueryData = [
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Value' },
          ],
          rows: [
            [time, 'Label Value 1', 42],
          ],
        }
      ];

      var multipleQueriesDataSameLabels = [
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Label Key 2' },
            { text: 'Value #A' },
          ],
          rows: [
            [time, 'Label Value 1', 'Label Value 2', 42],
          ],
        },
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Label Key 2' },
            { text: 'Value #B' },
          ],
          rows: [
            [time, 'Label Value 1', 'Label Value 2', 13],
          ],
        },
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Label Key 2' },
            { text: 'Value #C' },
          ],
          rows: [
            [time, 'Label Value 1', 'Label Value 2', 4],
          ],
        },
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Label Key 2' },
            { text: 'Value #C' },
          ],
          rows: [
            [time, 'Label Value 1', 'Label Value 2', 7],
          ],
        }
      ];

      var multipleQueriesDataDifferentLabels = [
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Value #A' },
          ],
          rows: [
            [time, 'Label Value 1', 42],
          ],
        },
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 2' },
            { text: 'Value #B' },
          ],
          rows: [
            [time, 'Label Value 2', 13],
          ],
        },
        {
          type: 'table',
          columns: [
            { text: 'Time' },
            { text: 'Label Key 1' },
            { text: 'Value #C' },
          ],
          rows: [
            [time, 'Label Value 3', 7],
          ],
        }
      ];

      describe('getColumns', function() {
        it('should return data columns given a single query', function() {
          var columns = transformers[transform].getColumns(singleQueryData);
          expect(columns[0].text).toBe('Time');
          expect(columns[1].text).toBe('Label Key 1');
          expect(columns[2].text).toBe('Value');
        });

        it('should return the union of data columns given a multiple queries', function() {
          var columns = transformers[transform].getColumns(multipleQueriesDataSameLabels);
          expect(columns[0].text).toBe('Time');
          expect(columns[1].text).toBe('Label Key 1');
          expect(columns[2].text).toBe('Label Key 2');
          expect(columns[3].text).toBe('Value #A');
          expect(columns[4].text).toBe('Value #B');
        });

        it('should return the union of data columns given a multiple queries with different labels', function() {
          var columns = transformers[transform].getColumns(multipleQueriesDataDifferentLabels);
          expect(columns[0].text).toBe('Time');
          expect(columns[1].text).toBe('Label Key 1');
          expect(columns[2].text).toBe('Value #A');
          expect(columns[3].text).toBe('Label Key 2');
          expect(columns[4].text).toBe('Value #B');
          expect(columns[5].text).toBe('Value #C');
        });
      });

      describe('transform', function() {
        it ('should throw an error with non-table data', () => {
          expect(() => transformDataToTable(nonTableData, panel)).toThrow();
        });

        it ('should return 3 columns for single queries', () => {
          table = transformDataToTable(singleQueryData, panel);
          expect(table.columns.length).toBe(3);
          expect(table.columns[0].text).toBe('Time');
          expect(table.columns[1].text).toBe('Label Key 1');
          expect(table.columns[2].text).toBe('Value');
        });

        it ('should return the union of columns for multiple queries', () => {
          table = transformDataToTable(multipleQueriesDataSameLabels, panel);
          expect(table.columns.length).toBe(6);
          expect(table.columns[0].text).toBe('Time');
          expect(table.columns[1].text).toBe('Label Key 1');
          expect(table.columns[2].text).toBe('Label Key 2');
          expect(table.columns[3].text).toBe('Value #A');
          expect(table.columns[4].text).toBe('Value #B');
          expect(table.columns[5].text).toBe('Value #C');
        });

        it ('should return 1 row for a single query', () => {
          table = transformDataToTable(singleQueryData, panel);
          expect(table.rows.length).toBe(1);
          expect(table.rows[0][0]).toBe(time);
          expect(table.rows[0][1]).toBe('Label Value 1');
          expect(table.rows[0][2]).toBe(42);
        });

        it ('should return 2 rows for a mulitple queries with same label values plus one extra row', () => {
          table = transformDataToTable(multipleQueriesDataSameLabels, panel);
          expect(table.rows.length).toBe(2);
          expect(table.rows[0][0]).toBe(time);
          expect(table.rows[0][1]).toBe('Label Value 1');
          expect(table.rows[0][2]).toBe('Label Value 2');
          expect(table.rows[0][3]).toBe(42);
          expect(table.rows[0][4]).toBe(13);
          expect(table.rows[0][5]).toBe(4);
          expect(table.rows[1][0]).toBe(time);
          expect(table.rows[1][1]).toBe('Label Value 1');
          expect(table.rows[1][2]).toBe('Label Value 2');
          expect(table.rows[1][3]).toBeUndefined();
          expect(table.rows[1][4]).toBeUndefined();
          expect(table.rows[1][5]).toBe(7);
        });

        it ('should return 2 rows for mulitple queries with different label values', () => {
          table = transformDataToTable(multipleQueriesDataDifferentLabels, panel);
          expect(table.rows.length).toBe(2);
          expect(table.columns.length).toBe(6);

          expect(table.rows[0][0]).toBe(time);
          expect(table.rows[0][1]).toBe('Label Value 1');
          expect(table.rows[0][2]).toBe(42);
          expect(table.rows[0][3]).toBe('Label Value 2');
          expect(table.rows[0][4]).toBe(13);
          expect(table.rows[0][5]).toBeUndefined();

          expect(table.rows[1][0]).toBe(time);
          expect(table.rows[1][1]).toBe('Label Value 3');
          expect(table.rows[1][2]).toBeUndefined();
          expect(table.rows[1][3]).toBeUndefined();
          expect(table.rows[1][4]).toBeUndefined();
          expect(table.rows[1][5]).toBe(7);
        });
      });
    });
  });

  describe('doc data sets', () => {
    describe('JSON Data', () => {
      var panel = {
        transform: 'json',
        columns: [
          {text: 'Timestamp', value: 'timestamp'},
          {text: 'Message', value: 'message'},
          {text: 'nested.level2', value: 'nested.level2'},
        ]
      };
      var rawData = [
        {
          type: 'docs',
          datapoints: [
            {
              timestamp: 'time',
              message: 'message',
              nested: {
                level2: 'level2-value'
              }
            }
          ]
        }
      ];

      describe('getColumns', function() {
        it('should return nested properties', function() {
          var columns = transformers['json'].getColumns(rawData);
          expect(columns[0].text).toBe('timestamp');
          expect(columns[1].text).toBe('message');
          expect(columns[2].text).toBe('nested.level2');
        });
      });

      describe('transform', function() {
        beforeEach(() => {
          table = transformDataToTable(rawData, panel);
        });

        it ('should return 2 columns', () => {
          expect(table.columns.length).toBe(3);
          expect(table.columns[0].text).toBe('Timestamp');
          expect(table.columns[1].text).toBe('Message');
          expect(table.columns[2].text).toBe('nested.level2');
        });

        it ('should return 2 rows', () => {
          expect(table.rows.length).toBe(1);
          expect(table.rows[0][0]).toBe('time');
          expect(table.rows[0][1]).toBe('message');
          expect(table.rows[0][2]).toBe('level2-value');
        });
      });
    });
  });

  describe('annotation data', () => {
    describe('Annnotations', () => {
      var panel = {transform: 'annotations'};
      var rawData = {
        annotations: [
          {
            time: 1000,
            text: 'hej',
            tags: ['tags', 'asd'],
            title: 'title',
          }
        ]
      };

      beforeEach(() => {
        table = transformDataToTable(rawData, panel);
      });

      it ('should return 4 columns', () => {
        expect(table.columns.length).toBe(4);
        expect(table.columns[0].text).toBe('Time');
        expect(table.columns[1].text).toBe('Title');
        expect(table.columns[2].text).toBe('Text');
        expect(table.columns[3].text).toBe('Tags');
      });

      it ('should return 1 rows', () => {
        expect(table.rows.length).toBe(1);
        expect(table.rows[0][0]).toBe(1000);
      });
    });

  });
});