prometheus

1
import * as React from 'react';
2
import { shallow, ShallowWrapper } from 'enzyme';
3
import SeriesName from './SeriesName';
4

5
describe('SeriesName', () => {
6
  describe('with labels=null', () => {
7
    const seriesNameProps = {
8
      labels: null,
9
      format: false,
10
    };
11
    const seriesName = shallow(<SeriesName {...seriesNameProps} />);
12
    it('renders the string "scalar"', () => {
13
      expect(seriesName.text()).toEqual('scalar');
14
    });
15
  });
16

17
  describe('with labels defined and format false', () => {
18
    const seriesNameProps = {
19
      labels: {
20
        __name__: 'metric_name',
21
        label1: 'value_1',
22
        label2: 'value_2',
23
        label3: 'value_3',
24
      },
25
      format: false,
26
    };
27
    const seriesName = shallow(<SeriesName {...seriesNameProps} />);
28
    it('renders the series name as a string', () => {
29
      expect(seriesName.text()).toEqual('metric_name{label1="value_1", label2="value_2", label3="value_3"}');
30
    });
31
  });
32

33
  describe('with labels defined and format true', () => {
34
    const seriesNameProps = {
35
      labels: {
36
        __name__: 'metric_name',
37
        label1: 'value_1',
38
        label2: 'value_2',
39
        label3: 'value_3',
40
      },
41
      format: true,
42
    };
43
    const seriesName = shallow(<SeriesName {...seriesNameProps} />);
44
    it('renders the series name as a series of spans', () => {
45
      expect(seriesName.children()).toHaveLength(6);
46
      const testCases = [
47
        { name: 'metric_name', className: 'legend-metric-name' },
48
        { name: '{', className: 'legend-label-brace' },
49
        { name: 'label1', value: 'value_1', className: 'legend-label-name' },
50
        { name: 'label2', value: 'value_2', className: 'legend-label-name' },
51
        { name: 'label3', value: 'value_3', className: 'legend-label-name' },
52
        { name: '}', className: 'legend-label-brace' },
53
      ];
54

55
      const testLabelContainerElement = (text: string, expectedText: string, container: ShallowWrapper) => {
56
        expect(text).toEqual(expectedText);
57
        expect(container.prop('className')).toEqual('legend-label-container');
58
        expect(container.childAt(0).prop('className')).toEqual('legend-label-name');
59
        expect(container.childAt(2).prop('className')).toEqual('legend-label-value');
60
      };
61

62
      testCases.forEach((tc, i) => {
63
        const child = seriesName.childAt(i);
64
        const firstChildElement = child.childAt(0);
65
        const firstChildElementClass = firstChildElement.prop('className');
66
        const text = child
67
          .children()
68
          .map((ch) => ch.text())
69
          .join('');
70
        switch (child.children().length) {
71
          case 1:
72
            switch (firstChildElementClass) {
73
              case 'legend-label-container':
74
                testLabelContainerElement(text, `${tc.name}="${tc.value}"`, firstChildElement);
75
                break;
76
              default:
77
                expect(text).toEqual(tc.name);
78
                expect(child.prop('className')).toEqual(tc.className);
79
            }
80
            break;
81
          case 2:
82
            const container = child.childAt(1);
83
            testLabelContainerElement(text, `, ${tc.name}="${tc.value}"`, container);
84
            break;
85
          default:
86
            fail('incorrect number of children: ' + child.children().length);
87
        }
88
      });
89
    });
90
  });
91
});
92