prometheus

1
import * as React from 'react';
2
import { mount, shallow } from 'enzyme';
3
import DataTable, { DataTableProps } from './DataTable';
4
import { Alert, Table } from 'reactstrap';
5
import SeriesName from './SeriesName';
6

7
describe('DataTable', () => {
8
  describe('when data is null', () => {
9
    it('renders an alert', () => {
10
      const table = shallow(<DataTable useLocalTime={false} data={null} />);
11
      const alert = table.find(Alert);
12
      expect(Object.keys(alert.props())).toHaveLength(7);
13
      expect(alert.prop('color')).toEqual('light');
14
      expect(alert.prop('children')).toEqual('No data queried yet');
15
    });
16
  });
17

18
  describe('when data.result is empty', () => {
19
    it('renders an alert', () => {
20
      const dataTableProps: DataTableProps = {
21
        data: {
22
          resultType: 'vector',
23
          result: [],
24
        },
25
        useLocalTime: false,
26
      };
27
      const table = shallow(<DataTable {...dataTableProps} />);
28
      const alert = table.find(Alert);
29
      expect(Object.keys(alert.props())).toHaveLength(7);
30
      expect(alert.prop('color')).toEqual('secondary');
31
      expect(alert.prop('children')).toEqual('Empty query result');
32
    });
33
  });
34

35
  describe('when resultType is a vector with values', () => {
36
    const dataTableProps: DataTableProps = {
37
      data: {
38
        resultType: 'vector',
39
        result: [
40
          {
41
            metric: {
42
              __name__: 'metric_name_1',
43
              label1: 'value_1',
44
              labeln: 'value_n',
45
            },
46
            value: [1572098246.599, '0'],
47
          },
48
          {
49
            metric: {
50
              __name__: 'metric_name_2',
51
              label1: 'value_1',
52
              labeln: 'value_n',
53
            },
54
            value: [1572098246.599, '1'],
55
          },
56
        ],
57
      },
58
      useLocalTime: false,
59
    };
60
    const dataTable = shallow(<DataTable {...dataTableProps} />);
61

62
    it('renders a table', () => {
63
      const table = dataTable.find(Table);
64
      expect(table.prop('hover')).toBe(true);
65
      expect(table.prop('size')).toEqual('sm');
66
      expect(table.prop('className')).toEqual('data-table');
67
      expect(table.find('tbody')).toHaveLength(1);
68
    });
69

70
    it('renders rows', () => {
71
      const table = dataTable.find(Table);
72
      table.find('tr').forEach((row, idx) => {
73
        expect(row.find(SeriesName)).toHaveLength(1);
74
        expect(row.find('td').at(1).text()).toEqual(`${idx}`);
75
      });
76
    });
77
  });
78

79
  describe('when resultType is a vector with histograms', () => {
80
    const dataTableProps: DataTableProps = {
81
      data: {
82
        resultType: 'vector',
83
        result: [
84
          {
85
            metric: {
86
              __name__: 'metric_name_1',
87
              label1: 'value_1',
88
              labeln: 'value_n',
89
            },
90
            histogram: [
91
              1572098246.599,
92
              {
93
                count: '10',
94
                sum: '3.3',
95
                buckets: [
96
                  [1, '-1', '-0.5', '2'],
97
                  [3, '-0.5', '0.5', '3'],
98
                  [0, '0.5', '1', '5'],
99
                ],
100
              },
101
            ],
102
          },
103
          {
104
            metric: {
105
              __name__: 'metric_name_2',
106
              label1: 'value_1',
107
              labeln: 'value_n',
108
            },
109
            histogram: [
110
              1572098247.599,
111
              {
112
                count: '5',
113
                sum: '1.11',
114
                buckets: [
115
                  [0, '0.5', '1', '2'],
116
                  [0, '1', '2', '3'],
117
                ],
118
              },
119
            ],
120
          },
121
          {
122
            metric: {
123
              __name__: 'metric_name_2',
124
              label1: 'value_1',
125
              labeln: 'value_n',
126
            },
127
          },
128
        ],
129
      },
130
      useLocalTime: false,
131
    };
132
    const dataTable = shallow(<DataTable {...dataTableProps} />);
133

134
    it('renders a table', () => {
135
      const table = dataTable.find(Table).first();
136
      expect(table.prop('hover')).toBe(true);
137
      expect(table.prop('size')).toEqual('sm');
138
      expect(table.prop('className')).toEqual('data-table');
139
      expect(table.find('tbody')).toHaveLength(dataTableProps.data?.result.length as number);
140
    });
141

142
    it('renders rows', () => {
143
      const table = dataTable.find(Table);
144
      table.find('tr').forEach((row, idx) => {
145
        const seriesNameComponent = dataTable.find('SeriesName');
146
        expect(seriesNameComponent).toHaveLength(dataTableProps.data?.result.length as number);
147
      });
148
    });
149
  });
150

151
  describe('when resultType is a vector with too many values', () => {
152
    const dataTableProps: DataTableProps = {
153
      data: {
154
        resultType: 'vector',
155
        result: Array.from(Array(10001).keys()).map((i) => {
156
          return {
157
            metric: {
158
              __name__: `metric_name_${i}`,
159
              label1: 'value_1',
160
              labeln: 'value_n',
161
            },
162
            value: [1572098246.599, `${i}`],
163
          };
164
        }),
165
      },
166
      useLocalTime: false,
167
    };
168
    const dataTable = shallow(<DataTable {...dataTableProps} />);
169

170
    it('renders limited rows', () => {
171
      const table = dataTable.find(Table);
172
      expect(table.find('tr')).toHaveLength(10000);
173
    });
174

175
    it('renders a warning', () => {
176
      const alerts = dataTable.find(Alert);
177
      expect(alerts.first().render().text()).toEqual('Warning: Fetched 10001 metrics, only displaying first 10000.');
178
    });
179
  });
180

181
  describe('when resultType is vector and size is more than maximum limit of formatting', () => {
182
    const dataTableProps: DataTableProps = {
183
      data: {
184
        resultType: 'vector',
185
        result: Array.from(Array(1001).keys()).map((i) => {
186
          return {
187
            metric: {
188
              __name__: `metric_name_${i}`,
189
              label1: 'value_1',
190
              labeln: 'value_n',
191
            },
192
            value: [1572098246.599, `${i}`],
193
          };
194
        }),
195
      },
196
      useLocalTime: false,
197
    };
198
    const dataTable = shallow(<DataTable {...dataTableProps} />);
199

200
    it('renders a warning', () => {
201
      const alerts = dataTable.find(Alert);
202
      expect(alerts.first().render().text()).toEqual(
203
        'Notice: Showing more than 1000 series, turning off label formatting for performance reasons.'
204
      );
205
    });
206
  });
207

208
  describe('when result type is a matrix', () => {
209
    const dataTableProps: DataTableProps = {
210
      data: {
211
        resultType: 'matrix',
212
        result: [
213
          {
214
            metric: {
215
              __name__: 'promhttp_metric_handler_requests_total',
216
              code: '200',
217
              instance: 'localhost:9090',
218
              job: 'prometheus',
219
            },
220
            values: [
221
              [1572097950.93, '9'],
222
              [1572097965.931, '10'],
223
              [1572097980.929, '11'],
224
              [1572097995.931, '12'],
225
              [1572098010.932, '13'],
226
              [1572098025.933, '14'],
227
              [1572098040.93, '15'],
228
              [1572098055.93, '16'],
229
              [1572098070.93, '17'],
230
              [1572098085.936, '18'],
231
              [1572098100.936, '19'],
232
              [1572098115.933, '20'],
233
              [1572098130.932, '21'],
234
              [1572098145.932, '22'],
235
              [1572098160.933, '23'],
236
              [1572098175.934, '24'],
237
              [1572098190.937, '25'],
238
              [1572098205.934, '26'],
239
              [1572098220.933, '27'],
240
              [1572098235.934, '28'],
241
            ],
242
          },
243
          {
244
            metric: {
245
              __name__: 'promhttp_metric_handler_requests_total',
246
              code: '500',
247
              instance: 'localhost:9090',
248
              job: 'prometheus',
249
            },
250
            values: [
251
              [1572097950.93, '0'],
252
              [1572097965.931, '0'],
253
              [1572097980.929, '0'],
254
              [1572097995.931, '0'],
255
              [1572098010.932, '0'],
256
              [1572098025.933, '0'],
257
              [1572098040.93, '0'],
258
              [1572098055.93, '0'],
259
              [1572098070.93, '0'],
260
              [1572098085.936, '0'],
261
              [1572098100.936, '0'],
262
              [1572098115.933, '0'],
263
              [1572098130.932, '0'],
264
              [1572098145.932, '0'],
265
              [1572098160.933, '0'],
266
              [1572098175.934, '0'],
267
              [1572098190.937, '0'],
268
              [1572098205.934, '0'],
269
              [1572098220.933, '0'],
270
              [1572098235.934, '0'],
271
            ],
272
          },
273
          {
274
            metric: {
275
              __name__: 'promhttp_metric_handler_requests_total',
276
              code: '503',
277
              instance: 'localhost:9090',
278
              job: 'prometheus',
279
            },
280
            values: [
281
              [1572097950.93, '0'],
282
              [1572097965.931, '0'],
283
              [1572097980.929, '0'],
284
              [1572097995.931, '0'],
285
              [1572098010.932, '0'],
286
              [1572098025.933, '0'],
287
              [1572098040.93, '0'],
288
              [1572098055.93, '0'],
289
              [1572098070.93, '0'],
290
              [1572098085.936, '0'],
291
              [1572098100.936, '0'],
292
              [1572098115.933, '0'],
293
              [1572098130.932, '0'],
294
              [1572098145.932, '0'],
295
              [1572098160.933, '0'],
296
              [1572098175.934, '0'],
297
              [1572098190.937, '0'],
298
              [1572098205.934, '0'],
299
              [1572098220.933, '0'],
300
              [1572098235.934, '0'],
301
            ],
302
          },
303
        ],
304
      },
305
      useLocalTime: false,
306
    };
307
    const dataTable = shallow(<DataTable {...dataTableProps} />);
308
    it('renders rows', () => {
309
      const table = dataTable.find(Table);
310
      const rows = table.find('tr');
311
      expect(table.find('tr')).toHaveLength(3);
312
      const row = rows.at(0);
313
      expect(row.text()).toEqual(
314
        `<SeriesName />9 @1572097950.9310 @1572097965.93111 @1572097980.92912 @1572097995.93113 @1572098010.93214 @1572098025.93315 @1572098040.9316 @1572098055.9317 @1572098070.9318 @1572098085.93619 @1572098100.93620 @1572098115.93321 @1572098130.93222 @1572098145.93223 @1572098160.93324 @1572098175.93425 @1572098190.93726 @1572098205.93427 @1572098220.93328 @1572098235.934 `
315
      );
316
    });
317
  });
318

319
  describe('when resultType is a scalar', () => {
320
    const dataTableProps: DataTableProps = {
321
      data: {
322
        resultType: 'scalar',
323
        result: [1572098246.599, '5'],
324
      },
325
      useLocalTime: false,
326
    };
327
    const dataTable = shallow(<DataTable {...dataTableProps} />);
328
    it('renders a scalar row', () => {
329
      const table = dataTable.find(Table);
330
      const rows = table.find('tr');
331
      expect(rows.text()).toEqual('scalar5');
332
    });
333
  });
334

335
  describe('when resultType is a string', () => {
336
    const dataTableProps: DataTableProps = {
337
      data: {
338
        resultType: 'string',
339
        result: [1572098246.599, 'test'],
340
      },
341
      useLocalTime: false,
342
    };
343
    const dataTable = shallow(<DataTable {...dataTableProps} />);
344
    it('renders a string row', () => {
345
      const table = dataTable.find(Table);
346
      const rows = table.find('tr');
347
      expect(rows.text()).toEqual('stringtest');
348
    });
349
  });
350
});
351