github.com/muhammadn/cortex@v1.9.1-0.20220510110439-46bb7000d03d/pkg/querier/series/series_set_test.go (about)

     1  package series
     2  
     3  import (
     4  	"math/rand"
     5  	"testing"
     6  
     7  	"github.com/prometheus/common/model"
     8  	"github.com/prometheus/prometheus/pkg/labels"
     9  	"github.com/prometheus/prometheus/storage"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func TestConcreteSeriesSet(t *testing.T) {
    14  	series1 := &ConcreteSeries{
    15  		labels:  labels.FromStrings("foo", "bar"),
    16  		samples: []model.SamplePair{{Value: 1, Timestamp: 2}},
    17  	}
    18  	series2 := &ConcreteSeries{
    19  		labels:  labels.FromStrings("foo", "baz"),
    20  		samples: []model.SamplePair{{Value: 3, Timestamp: 4}},
    21  	}
    22  	c := NewConcreteSeriesSet([]storage.Series{series2, series1})
    23  	require.True(t, c.Next())
    24  	require.Equal(t, series1, c.At())
    25  	require.True(t, c.Next())
    26  	require.Equal(t, series2, c.At())
    27  	require.False(t, c.Next())
    28  }
    29  
    30  func TestMatrixToSeriesSetSortsMetricLabels(t *testing.T) {
    31  	matrix := model.Matrix{
    32  		{
    33  			Metric: model.Metric{
    34  				model.MetricNameLabel: "testmetric",
    35  				"e":                   "f",
    36  				"a":                   "b",
    37  				"g":                   "h",
    38  				"c":                   "d",
    39  			},
    40  			Values: []model.SamplePair{{Timestamp: 0, Value: 0}},
    41  		},
    42  	}
    43  	ss := MatrixToSeriesSet(matrix)
    44  	require.True(t, ss.Next())
    45  	require.NoError(t, ss.Err())
    46  
    47  	l := ss.At().Labels()
    48  	require.Equal(t, labels.Labels{
    49  		{Name: string(model.MetricNameLabel), Value: "testmetric"},
    50  		{Name: "a", Value: "b"},
    51  		{Name: "c", Value: "d"},
    52  		{Name: "e", Value: "f"},
    53  		{Name: "g", Value: "h"},
    54  	}, l)
    55  }
    56  
    57  func TestDeletedSeriesIterator(t *testing.T) {
    58  	cs := ConcreteSeries{labels: labels.FromStrings("foo", "bar")}
    59  	// Insert random stuff from (0, 1000).
    60  	for i := 0; i < 1000; i++ {
    61  		cs.samples = append(cs.samples, model.SamplePair{Timestamp: model.Time(i), Value: model.SampleValue(rand.Float64())})
    62  	}
    63  
    64  	cases := []struct {
    65  		r []model.Interval
    66  	}{
    67  		{r: []model.Interval{{Start: 1, End: 20}}},
    68  		{r: []model.Interval{{Start: 1, End: 10}, {Start: 12, End: 20}, {Start: 21, End: 23}, {Start: 25, End: 30}}},
    69  		{r: []model.Interval{{Start: 1, End: 10}, {Start: 12, End: 20}, {Start: 20, End: 30}}},
    70  		{r: []model.Interval{{Start: 1, End: 10}, {Start: 12, End: 23}, {Start: 25, End: 30}}},
    71  		{r: []model.Interval{{Start: 1, End: 23}, {Start: 12, End: 20}, {Start: 25, End: 30}}},
    72  		{r: []model.Interval{{Start: 1, End: 23}, {Start: 12, End: 20}, {Start: 25, End: 3000}}},
    73  		{r: []model.Interval{{Start: 0, End: 2000}}},
    74  		{r: []model.Interval{{Start: 500, End: 2000}}},
    75  		{r: []model.Interval{{Start: 0, End: 200}}},
    76  		{r: []model.Interval{{Start: 1000, End: 20000}}},
    77  	}
    78  
    79  	for _, c := range cases {
    80  		i := int64(-1)
    81  		it := NewDeletedSeriesIterator(NewConcreteSeriesIterator(&cs), c.r)
    82  		ranges := c.r[:]
    83  
    84  		for it.Next() {
    85  			i++
    86  			for _, tr := range ranges {
    87  				if inbound(model.Time(i), tr) {
    88  					i = int64(tr.End + 1)
    89  					ranges = ranges[1:]
    90  				}
    91  			}
    92  
    93  			require.Equal(t, true, i < 1000)
    94  
    95  			ts, v := it.At()
    96  			require.Equal(t, int64(cs.samples[i].Timestamp), ts)
    97  			require.Equal(t, float64(cs.samples[i].Value), v)
    98  		}
    99  
   100  		// There has been an extra call to Next().
   101  		i++
   102  		for _, tr := range ranges {
   103  			if inbound(model.Time(i), tr) {
   104  				i = int64(tr.End + 1)
   105  				ranges = ranges[1:]
   106  			}
   107  		}
   108  
   109  		require.Equal(t, true, i >= 1000)
   110  		require.NoError(t, it.Err())
   111  	}
   112  }
   113  
   114  func TestDeletedIterator_WithSeek(t *testing.T) {
   115  	cs := ConcreteSeries{labels: labels.FromStrings("foo", "bar")}
   116  	// Insert random stuff from (0, 1000).
   117  	for i := 0; i < 1000; i++ {
   118  		cs.samples = append(cs.samples, model.SamplePair{Timestamp: model.Time(i), Value: model.SampleValue(rand.Float64())})
   119  	}
   120  
   121  	cases := []struct {
   122  		r        []model.Interval
   123  		seek     int64
   124  		ok       bool
   125  		seekedTs int64
   126  	}{
   127  		{r: []model.Interval{{Start: 1, End: 20}}, seek: 1, ok: true, seekedTs: 21},
   128  		{r: []model.Interval{{Start: 1, End: 20}}, seek: 20, ok: true, seekedTs: 21},
   129  		{r: []model.Interval{{Start: 1, End: 20}}, seek: 10, ok: true, seekedTs: 21},
   130  		{r: []model.Interval{{Start: 1, End: 20}}, seek: 999, ok: true, seekedTs: 999},
   131  		{r: []model.Interval{{Start: 1, End: 20}}, seek: 1000, ok: false},
   132  		{r: []model.Interval{{Start: 1, End: 23}, {Start: 24, End: 40}, {Start: 45, End: 3000}}, seek: 1, ok: true, seekedTs: 41},
   133  		{r: []model.Interval{{Start: 5, End: 23}, {Start: 24, End: 40}, {Start: 41, End: 3000}}, seek: 5, ok: false},
   134  		{r: []model.Interval{{Start: 0, End: 2000}}, seek: 10, ok: false},
   135  		{r: []model.Interval{{Start: 500, End: 2000}}, seek: 10, ok: true, seekedTs: 10},
   136  		{r: []model.Interval{{Start: 500, End: 2000}}, seek: 501, ok: false},
   137  	}
   138  
   139  	for _, c := range cases {
   140  		it := NewDeletedSeriesIterator(NewConcreteSeriesIterator(&cs), c.r)
   141  
   142  		require.Equal(t, c.ok, it.Seek(c.seek))
   143  		if c.ok {
   144  			ts, _ := it.At()
   145  			require.Equal(t, c.seekedTs, ts)
   146  		}
   147  	}
   148  }
   149  
   150  func inbound(t model.Time, interval model.Interval) bool {
   151  	return interval.Start <= t && t <= interval.End
   152  }