grafana/public/test/specs/elasticsearch-response-specs.js

define([
  'app/plugins/datasource/elasticsearch/elasticResponse',
], function(ElasticResponse) {
  'use strict';

  describe('ElasticResponse', function() {
    var targets;
    var response;
    var result;

    describe('simple query and count', function() {

      beforeEach(function() {
        targets = [{
          refId: 'A',
          metrics: [{type: 'count', id: '1'}],
          bucketAggs: [{type: 'date_histogram', field: '@timestamp', id: '2'}],
        }];
        response = {
          responses: [{
            aggregations: {
              "2": {
                buckets: [
                  {
                    doc_count: 10,
                    key: 1000
                  },
                  {
                    doc_count: 15,
                    key: 2000
                  }
                ]
              }
            }
          }]
        };

        result = new ElasticResponse(targets, response).getTimeSeries();
      });

      it('should return 1 series', function() {
        expect(result.data.length).to.be(1);
        expect(result.data[0].target).to.be('Count');
        expect(result.data[0].datapoints.length).to.be(2);
        expect(result.data[0].datapoints[0][0]).to.be(10);
        expect(result.data[0].datapoints[0][1]).to.be(1000);
      });

    });

    describe('simple query count & avg aggregation', function() {
      var result;

      beforeEach(function() {
        targets = [{
          refId: 'A',
          metrics: [{type: 'count', id: '1'}, {type: 'avg', field: 'value', id: '2'}],
          bucketAggs: [{type: 'date_histogram', field: '@timestamp', id: '3'}],
        }];
        response = {
          responses: [{
            aggregations: {
              "3": {
                buckets: [
                  {
                    "2": {value: 88},
                    doc_count: 10,
                    key: 1000
                  },
                  {
                    "2": {value: 99},
                    doc_count: 15,
                    key: 2000
                  }
                ]
              }
            }
          }]
        };

        result = new ElasticResponse(targets, response).getTimeSeries();
      });

      it('should return 2 series', function() {
        expect(result.data.length).to.be(2);
        expect(result.data[0].datapoints.length).to.be(2);
        expect(result.data[0].datapoints[0][0]).to.be(10);
        expect(result.data[0].datapoints[0][1]).to.be(1000);

        expect(result.data[1].target).to.be("Average value");
        expect(result.data[1].datapoints[0][0]).to.be(88);
        expect(result.data[1].datapoints[1][0]).to.be(99);
      });

    });

    describe('single group by query one metric', function() {
      var result;

      beforeEach(function() {
        targets = [{
          refId: 'A',
          metrics: [{type: 'count', id: '1'}],
          bucketAggs: [{type: 'terms', field: 'host', id: '2'}, {type: 'date_histogram', field: '@timestamp', id: '3'}],
        }];
        response =  {
          responses: [{
            aggregations: {
              "2": {
                buckets: [
                  {
                    "3": {
                      buckets: [
                        {doc_count: 1, key: 1000},
                        {doc_count: 3, key: 2000}
                      ]
                    },
                    doc_count: 4,
                    key: 'server1',
                  },
                  {
                    "3": {
                      buckets: [
                        {doc_count: 2, key: 1000},
                        {doc_count: 8, key: 2000}
                      ]
                    },
                    doc_count: 10,
                    key: 'server2',
                  },
                ]
              }
            }
          }]
        };

        result = new ElasticResponse(targets, response).getTimeSeries();
      });

      it('should return 2 series', function() {
        expect(result.data.length).to.be(2);
        expect(result.data[0].datapoints.length).to.be(2);
        expect(result.data[0].target).to.be('server1');
        expect(result.data[1].target).to.be('server2');
      });
    });

    describe('single group by query two metrics', function() {
      var result;

      beforeEach(function() {
        targets = [{
          refId: 'A',
          metrics: [{type: 'count', id: '1'}, {type: 'avg', field: '@value', id: '4'}],
          bucketAggs: [{type: 'terms', field: 'host', id: '2'}, {type: 'date_histogram', field: '@timestamp', id: '3'}],
        }];
        response =  {
          responses: [{
            aggregations: {
              "2": {
                buckets: [
                  {
                    "3": {
                      buckets: [
                        { "4": {value: 10}, doc_count: 1, key: 1000},
                        { "4": {value: 12}, doc_count: 3, key: 2000}
                      ]
                    },
                    doc_count: 4,
                    key: 'server1',
                  },
                  {
                    "3": {
                      buckets: [
                        { "4": {value: 20}, doc_count: 1, key: 1000},
                        { "4": {value: 32}, doc_count: 3, key: 2000}
                      ]
                    },
                    doc_count: 10,
                    key: 'server2',
                  },
                ]
              }
            }
          }]
        };

        result = new ElasticResponse(targets, response).getTimeSeries();
      });

      it('should return 2 series', function() {
        expect(result.data.length).to.be(4);
        expect(result.data[0].datapoints.length).to.be(2);
        expect(result.data[0].target).to.be('server1 Count');
        expect(result.data[1].target).to.be('server1 Average @value');
        expect(result.data[2].target).to.be('server2 Count');
        expect(result.data[3].target).to.be('server2 Average @value');
      });
    });

    describe('with percentiles ', function() {
      var result;

      beforeEach(function() {
        targets = [{
          refId: 'A',
          metrics: [{type: 'percentiles', settings: {percents: [75, 90]},  id: '1'}],
          bucketAggs: [{type: 'date_histogram', field: '@timestamp', id: '3'}],
        }];
        response = {
          responses: [{
            aggregations: {
              "3": {
                buckets: [
                  {
                    "1": {values: {"75": 3.3, "90": 5.5}},
                    doc_count: 10,
                    key: 1000
                  },
                  {
                    "1": {values: {"75": 2.3, "90": 4.5}},
                    doc_count: 15,
                    key: 2000
                  }
                ]
              }
            }
          }]
        };

        result = new ElasticResponse(targets, response).getTimeSeries();
      });

      it('should return 2 series', function() {
        expect(result.data.length).to.be(2);
        expect(result.data[0].datapoints.length).to.be(2);
        expect(result.data[0].target).to.be('p75');
        expect(result.data[1].target).to.be('p90');
        expect(result.data[0].datapoints[0][0]).to.be(3.3);
        expect(result.data[0].datapoints[0][1]).to.be(1000);
        expect(result.data[1].datapoints[1][0]).to.be(4.5);
      });
    });

    describe('with extended_stats', function() {
      var result;

      beforeEach(function() {
        targets = [{
          refId: 'A',
          metrics: [{type: 'extended_stats', meta: {max: true, std_deviation_bounds_upper: true},  id: '1'}],
          bucketAggs: [{type: 'terms', field: 'host', id: '3'}, {type: 'date_histogram', id: '4'}],
        }];
        response = {
          responses: [{
            aggregations: {
              "3": {
                buckets: [
                  {
                    key: 'server1',
                    "4": {
                      buckets: [{
                        "1": {max: 10.2, min: 5.5, std_deviation_bounds: {upper: 3, lower: -2}},
                        doc_count: 10,
                        key: 1000
                      }]
                    }
                  },
                  {
                    key: 'server2',
                    "4": {
                      buckets: [{
                        "1": {max: 10.2, min: 5.5, std_deviation_bounds: {upper: 3, lower: -2}},
                        doc_count: 10,
                        key: 1000
                      }]
                    }
                  },
                ]
              }
            }
          }]
        };

        result = new ElasticResponse(targets, response).getTimeSeries();
      });

      it('should return 4 series', function() {
        expect(result.data.length).to.be(4);
        expect(result.data[0].datapoints.length).to.be(1);
        expect(result.data[0].target).to.be('server1 Max');
        expect(result.data[1].target).to.be('server1 Std Dev Upper');

        expect(result.data[0].datapoints[0][0]).to.be(10.2);
        expect(result.data[1].datapoints[0][0]).to.be(3);
      });
    });

    describe('single group by with alias pattern', function() {
      var result;

      beforeEach(function() {
        targets = [{
          refId: 'A',
          metrics: [{type: 'count', id: '1'}],
          alias: '{{term @host}} {{metric}} and!',
          bucketAggs: [
            {type: 'terms', field: '@host', id: '2'},
            {type: 'date_histogram', field: '@timestamp', id: '3'}
          ],
        }];
        response =  {
          responses: [{
            aggregations: {
              "2": {
                buckets: [
                  {
                    "3": {
                      buckets: [
                        {doc_count: 1, key: 1000},
                        {doc_count: 3, key: 2000}
                      ]
                    },
                    doc_count: 4,
                    key: 'server1',
                  },
                  {
                    "3": {
                      buckets: [
                        {doc_count: 2, key: 1000},
                        {doc_count: 8, key: 2000}
                      ]
                    },
                    doc_count: 10,
                    key: 'server2',
                  },
                ]
              }
            }
          }]
        };

        result = new ElasticResponse(targets, response).getTimeSeries();
      });

      it('should return 2 series', function() {
        expect(result.data.length).to.be(2);
        expect(result.data[0].datapoints.length).to.be(2);
        expect(result.data[0].target).to.be('server1 Count and!');
        expect(result.data[1].target).to.be('server2 Count and!');
      });
    });

  });
});