1import { size } from 'lodash';
2import ResponseParser from '../response_parser';
3
4describe('influxdb response parser', () => {
5  const parser = new ResponseParser();
6
7  describe('SHOW TAG response', () => {
8    const query = 'SHOW TAG KEYS FROM "cpu"';
9    const response = {
10      results: [
11        {
12          series: [
13            {
14              name: 'cpu',
15              columns: ['tagKey'],
16              values: [['datacenter'], ['hostname'], ['source']],
17            },
18          ],
19        },
20      ],
21    };
22
23    const result = parser.parse(query, response);
24
25    it('expects three results', () => {
26      expect(size(result)).toBe(3);
27    });
28  });
29
30  describe('SHOW TAG VALUES response', () => {
31    const query = 'SHOW TAG VALUES FROM "cpu" WITH KEY = "hostname"';
32
33    describe('response from 0.10.0', () => {
34      const response = {
35        results: [
36          {
37            series: [
38              {
39                name: 'hostnameTagValues',
40                columns: ['hostname'],
41                values: [['server1'], ['server2'], ['server2']],
42              },
43            ],
44          },
45        ],
46      };
47
48      const result = parser.parse(query, response);
49
50      it('should get two responses', () => {
51        expect(size(result)).toBe(2);
52        expect(result[0].text).toBe('server1');
53        expect(result[1].text).toBe('server2');
54      });
55    });
56
57    describe('response from 0.12.0', () => {
58      const response = {
59        results: [
60          {
61            series: [
62              {
63                name: 'cpu',
64                columns: ['key', 'value'],
65                values: [
66                  ['source', 'site'],
67                  ['source', 'api'],
68                ],
69              },
70              {
71                name: 'logins',
72                columns: ['key', 'value'],
73                values: [
74                  ['source', 'site'],
75                  ['source', 'webapi'],
76                ],
77              },
78            ],
79          },
80        ],
81      };
82
83      const result = parser.parse(query, response);
84
85      it('should get two responses', () => {
86        expect(size(result)).toBe(3);
87        expect(result[0].text).toBe('site');
88        expect(result[1].text).toBe('api');
89        expect(result[2].text).toBe('webapi');
90      });
91    });
92  });
93
94  describe('SELECT response', () => {
95    const query = 'SELECT "usage_iowait" FROM "cpu" LIMIT 10';
96    const response = {
97      results: [
98        {
99          series: [
100            {
101              name: 'cpu',
102              columns: ['time', 'usage_iowait'],
103              values: [
104                [1488465190006040638, 0.0],
105                [1488465190006040638, 15.0],
106                [1488465190006040638, 20.2],
107              ],
108            },
109          ],
110        },
111      ],
112    };
113
114    const result = parser.parse(query, response);
115
116    it('should return second column', () => {
117      expect(size(result)).toBe(3);
118      expect(result[0].text).toBe('0');
119      expect(result[1].text).toBe('15');
120      expect(result[2].text).toBe('20.2');
121    });
122  });
123
124  describe('SELECT response where ordering matters', () => {
125    const query = 'SELECT "val" from "num"';
126    const response = {
127      results: [
128        {
129          series: [
130            {
131              name: 'num',
132              columns: ['time', 'val'],
133              values: [
134                [1620041231000, 2],
135                [1620041233000, 3],
136                [1620041235000, 4],
137                [1620041238000, 5],
138                [1620041239000, 1],
139              ],
140            },
141          ],
142        },
143      ],
144    };
145
146    it('should keep the order returned by influxdb, even for numbers', () => {
147      expect(parser.parse(query, response)).toStrictEqual([
148        { text: '2' },
149        { text: '3' },
150        { text: '4' },
151        { text: '5' },
152        { text: '1' },
153      ]);
154    });
155  });
156
157  describe('SHOW FIELD response', () => {
158    const query = 'SHOW FIELD KEYS FROM "cpu"';
159
160    describe('response from pre-1.0', () => {
161      const response = {
162        results: [
163          {
164            series: [
165              {
166                name: 'cpu',
167                columns: ['fieldKey'],
168                values: [['value']],
169              },
170            ],
171          },
172        ],
173      };
174
175      const result = parser.parse(query, response);
176
177      it('should get two responses', () => {
178        expect(size(result)).toBe(1);
179      });
180    });
181
182    describe('response from 1.0', () => {
183      const response = {
184        results: [
185          {
186            series: [
187              {
188                name: 'cpu',
189                columns: ['fieldKey', 'fieldType'],
190                values: [['time', 'float']],
191              },
192            ],
193          },
194        ],
195      };
196
197      const result = parser.parse(query, response);
198
199      it('should return first column', () => {
200        expect(size(result)).toBe(1);
201        expect(result[0].text).toBe('time');
202      });
203    });
204  });
205});
206