github.com/netdata/go.d.plugin@v0.58.1/pkg/prometheus/metric_series_test.go (about)

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package prometheus
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/prometheus/prometheus/model/labels"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  // TODO: write better tests
    14  
    15  const (
    16  	testName1 = "logback_events_total"
    17  	testName2 = "jvm_threads_peak"
    18  )
    19  
    20  func newTestSeries() Series {
    21  	return Series{
    22  		{
    23  			Value: 10,
    24  			Labels: labels.Labels{
    25  				{Name: "__name__", Value: testName1},
    26  				{Name: "level", Value: "error"},
    27  			},
    28  		},
    29  		{
    30  			Value: 20,
    31  			Labels: labels.Labels{
    32  				{Name: "__name__", Value: testName1},
    33  				{Name: "level", Value: "warn"},
    34  			},
    35  		},
    36  		{
    37  			Value: 5,
    38  			Labels: labels.Labels{
    39  				{Name: "__name__", Value: testName1},
    40  				{Name: "level", Value: "info"},
    41  			},
    42  		},
    43  		{
    44  			Value: 15,
    45  			Labels: labels.Labels{
    46  				{Name: "__name__", Value: testName1},
    47  				{Name: "level", Value: "debug"},
    48  			},
    49  		},
    50  		{
    51  			Value: 26,
    52  			Labels: labels.Labels{
    53  				{Name: "__name__", Value: testName2},
    54  			},
    55  		},
    56  	}
    57  }
    58  
    59  func TestSeries_Name(t *testing.T) {
    60  	m := newTestSeries()
    61  
    62  	assert.Equal(t, testName1, m[0].Name())
    63  	assert.Equal(t, testName1, m[1].Name())
    64  
    65  }
    66  
    67  func TestSeries_Add(t *testing.T) {
    68  	m := newTestSeries()
    69  
    70  	require.Len(t, m, 5)
    71  	m.Add(SeriesSample{})
    72  	assert.Len(t, m, 6)
    73  }
    74  
    75  func TestSeries_FindByName(t *testing.T) {
    76  	m := newTestSeries()
    77  	m.Sort()
    78  	assert.Len(t, Series{}.FindByName(testName1), 0)
    79  	assert.Len(t, m.FindByName(testName1), len(m)-1)
    80  }
    81  
    82  func TestSeries_FindByNames(t *testing.T) {
    83  	m := newTestSeries()
    84  	m.Sort()
    85  	assert.Len(t, m.FindByNames(), 0)
    86  	assert.Len(t, m.FindByNames(testName1), len(m)-1)
    87  	assert.Len(t, m.FindByNames(testName1, testName2), len(m))
    88  }
    89  
    90  func TestSeries_Len(t *testing.T) {
    91  	m := newTestSeries()
    92  
    93  	assert.Equal(t, len(m), m.Len())
    94  }
    95  
    96  func TestSeries_Less(t *testing.T) {
    97  	m := newTestSeries()
    98  
    99  	assert.False(t, m.Less(0, 1))
   100  	assert.True(t, m.Less(4, 0))
   101  }
   102  
   103  func TestSeries_Max(t *testing.T) {
   104  	m := newTestSeries()
   105  
   106  	assert.Equal(t, float64(26), m.Max())
   107  
   108  }
   109  
   110  func TestSeries_Reset(t *testing.T) {
   111  	m := newTestSeries()
   112  	m.Reset()
   113  
   114  	assert.Len(t, m, 0)
   115  
   116  }
   117  
   118  func TestSeries_Sort(t *testing.T) {
   119  	{
   120  		m := newTestSeries()
   121  		m.Sort()
   122  		assert.Equal(t, testName2, m[0].Name())
   123  	}
   124  	{
   125  		m := Series{}
   126  		assert.Equal(t, 0.0, m.Max())
   127  	}
   128  }
   129  
   130  func TestSeries_Swap(t *testing.T) {
   131  	m := newTestSeries()
   132  
   133  	m0 := m[0]
   134  	m1 := m[1]
   135  
   136  	m.Swap(0, 1)
   137  
   138  	assert.Equal(t, m0, m[1])
   139  	assert.Equal(t, m1, m[0])
   140  }