github.com/siglens/siglens@v0.0.0-20240328180423-f7ce9ae441ed/pkg/segment/results/mresults/seriesresult_test.go (about)

     1  /*
     2  Copyright 2023.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package mresults
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/siglens/siglens/pkg/common/dtypeutils"
    23  	segutils "github.com/siglens/siglens/pkg/segment/utils"
    24  	"github.com/stretchr/testify/assert"
    25  )
    26  
    27  func Test_applyRangeFunctionRate(t *testing.T) {
    28  	timeSeries := map[uint32]float64{
    29  		0: 2.0,
    30  		1: 3.0,
    31  		2: 4.0,
    32  		3: 0.0,
    33  		8: 2.5,
    34  		9: 1.0,
    35  	}
    36  
    37  	rate, err := ApplyRangeFunction(timeSeries, segutils.Rate)
    38  	assert.Nil(t, err)
    39  
    40  	// There's six timestamps in the series, but we need two points to calculate
    41  	// the rate, so we can't calculate it on the first point. So we should have
    42  	// 5 elements in the result.
    43  	assert.Len(t, rate, 5)
    44  
    45  	var val float64
    46  	var ok bool
    47  
    48  	val, ok = rate[1]
    49  	assert.True(t, ok)
    50  	assert.True(t, dtypeutils.AlmostEquals(val, (3.0-2.0)/(1-0)))
    51  
    52  	val, ok = rate[2]
    53  	assert.True(t, ok)
    54  	assert.True(t, dtypeutils.AlmostEquals(val, (4.0-3.0)/(2-1)))
    55  
    56  	val, ok = rate[3]
    57  	assert.True(t, ok)
    58  	// Since the value here is smaller than at the last timestamp, the value was
    59  	// reset since the last timestamp. So the increase is just this value, not
    60  	// this value minus the previous value.
    61  	assert.True(t, dtypeutils.AlmostEquals(val, 0.0))
    62  
    63  	val, ok = rate[8]
    64  	assert.True(t, ok)
    65  	assert.True(t, dtypeutils.AlmostEquals(val, 2.5/(8-3)))
    66  
    67  	val, ok = rate[9]
    68  	assert.True(t, ok)
    69  	// Since the value here is smaller than at the last timestamp, the value was
    70  	// reset since the last timestamp. So the increase is just this value, not
    71  	// this value minus the previous value.
    72  	assert.True(t, dtypeutils.AlmostEquals(val, 1.0/(9-8)))
    73  }
    74  
    75  func Test_reduceEntries(t *testing.T) {
    76  	entries := []Entry{
    77  		Entry{downsampledTime: 0, dpVal: 4.3},
    78  		Entry{downsampledTime: 1, dpVal: 5.0},
    79  		Entry{downsampledTime: 2, dpVal: 1.7},
    80  		Entry{downsampledTime: 8, dpVal: 5.0},
    81  		Entry{downsampledTime: 5, dpVal: 0.0},
    82  	}
    83  
    84  	var functionConstant float64 // Only needed for quantile.
    85  	var val float64
    86  	var err error
    87  
    88  	val, err = reduceEntries(entries, segutils.Count, functionConstant)
    89  	assert.Nil(t, err)
    90  	assert.True(t, dtypeutils.AlmostEquals(5.0, val))
    91  
    92  	val, err = reduceEntries(entries, segutils.Sum, functionConstant)
    93  	assert.Nil(t, err)
    94  	assert.True(t, dtypeutils.AlmostEquals(16.0, val))
    95  
    96  	val, err = reduceEntries(entries, segutils.Max, functionConstant)
    97  	assert.Nil(t, err)
    98  	assert.True(t, dtypeutils.AlmostEquals(5.0, val))
    99  
   100  	val, err = reduceEntries(entries, segutils.Min, functionConstant)
   101  	assert.Nil(t, err)
   102  	assert.True(t, dtypeutils.AlmostEquals(0.0, val))
   103  
   104  	functionConstant = 0.5 // The median should be exactly 4.3
   105  	val, err = reduceEntries(entries, segutils.Quantile, functionConstant)
   106  	assert.Nil(t, err)
   107  	assert.True(t, dtypeutils.AlmostEquals(4.3, val))
   108  
   109  	functionConstant = 0.0 // The 0th percentile should be the min element
   110  	val, err = reduceEntries(entries, segutils.Quantile, functionConstant)
   111  	assert.Nil(t, err)
   112  	assert.True(t, dtypeutils.AlmostEquals(0.0, val))
   113  
   114  	functionConstant = 1.0 // The 100th percentile should be the max element
   115  	val, err = reduceEntries(entries, segutils.Quantile, functionConstant)
   116  	assert.Nil(t, err)
   117  	assert.True(t, dtypeutils.AlmostEquals(5.0, val))
   118  
   119  	// Since there are 5 elements, there are 4 buckets. So the 37.5th percentile
   120  	// should be directly between sorted elements at index 1 and 2. Those
   121  	// elements are 1.7 and 4.3, so the value should be 3.0.
   122  	functionConstant = 0.375
   123  	val, err = reduceEntries(entries, segutils.Quantile, functionConstant)
   124  	assert.Nil(t, err)
   125  	assert.True(t, dtypeutils.AlmostEquals(3.0, val))
   126  
   127  	// Each quantile bucket has size 0.25, so at 0.25 * 1.25 = 0.25 + 0.0625 =
   128  	// 0.3125, the quantile should be a quarter way between the elements at
   129  	// indices 1 and 2. So 1.7 * 0.75 + 4.3 * 0.25 = 2.35.
   130  	functionConstant = 0.3125
   131  	val, err = reduceEntries(entries, segutils.Quantile, functionConstant)
   132  	assert.Nil(t, err)
   133  	assert.True(t, dtypeutils.AlmostEquals(2.35, val))
   134  
   135  	// Avg is not implemented yet, so this should error.
   136  	_, err = reduceEntries(entries, segutils.Avg, functionConstant)
   137  	assert.NotNil(t, err)
   138  
   139  	// Cardinality is not implemented yet, so this should error.
   140  	_, err = reduceEntries(entries, segutils.Cardinality, functionConstant)
   141  	assert.NotNil(t, err)
   142  }
   143  
   144  func Test_reduceRunningEntries(t *testing.T) {
   145  	entries := []RunningEntry{
   146  		RunningEntry{downsampledTime: 0, runningVal: 4.3, runningCount: 1},
   147  		RunningEntry{downsampledTime: 1, runningVal: 5.0, runningCount: 1},
   148  		RunningEntry{downsampledTime: 2, runningVal: 1.7, runningCount: 1},
   149  		RunningEntry{downsampledTime: 8, runningVal: 5.0, runningCount: 1},
   150  		RunningEntry{downsampledTime: 5, runningVal: 0.0, runningCount: 1},
   151  	}
   152  
   153  	var functionConstant float64 // Only needed for quantile.
   154  	var val float64
   155  	var err error
   156  
   157  	val, err = reduceRunningEntries(entries, segutils.Avg, functionConstant)
   158  	assert.Nil(t, err)
   159  	assert.True(t, dtypeutils.AlmostEquals(16.0/5, val))
   160  
   161  	val, err = reduceRunningEntries(entries, segutils.Count, functionConstant)
   162  	assert.Nil(t, err)
   163  	assert.True(t, dtypeutils.AlmostEquals(5.0, val))
   164  
   165  	val, err = reduceRunningEntries(entries, segutils.Sum, functionConstant)
   166  	assert.Nil(t, err)
   167  	assert.True(t, dtypeutils.AlmostEquals(16.0, val))
   168  
   169  	val, err = reduceRunningEntries(entries, segutils.Max, functionConstant)
   170  	assert.Nil(t, err)
   171  	assert.True(t, dtypeutils.AlmostEquals(5.0, val))
   172  
   173  	val, err = reduceRunningEntries(entries, segutils.Min, functionConstant)
   174  	assert.Nil(t, err)
   175  	assert.True(t, dtypeutils.AlmostEquals(0.0, val))
   176  
   177  	functionConstant = 0.5 // The median should be exactly 4.3
   178  	val, err = reduceRunningEntries(entries, segutils.Quantile, functionConstant)
   179  	assert.Nil(t, err)
   180  	assert.True(t, dtypeutils.AlmostEquals(4.3, val))
   181  
   182  	functionConstant = 0.0 // The 0th percentile should be the min element
   183  	val, err = reduceRunningEntries(entries, segutils.Quantile, functionConstant)
   184  	assert.Nil(t, err)
   185  	assert.True(t, dtypeutils.AlmostEquals(0.0, val))
   186  
   187  	functionConstant = 1.0 // The 100th percentile should be the max element
   188  	val, err = reduceRunningEntries(entries, segutils.Quantile, functionConstant)
   189  	assert.Nil(t, err)
   190  	assert.True(t, dtypeutils.AlmostEquals(5.0, val))
   191  
   192  	// Since there are 5 elements, there are 4 buckets. So the 37.5th percentile
   193  	// should be directly between sorted elements at index 1 and 2. Those
   194  	// elements are 1.7 and 4.3, so the value should be 3.0.
   195  	functionConstant = 0.375
   196  	val, err = reduceRunningEntries(entries, segutils.Quantile, functionConstant)
   197  	assert.Nil(t, err)
   198  	assert.True(t, dtypeutils.AlmostEquals(3.0, val))
   199  
   200  	// Each quantile bucket has size 0.25, so at 0.25 * 1.25 = 0.25 + 0.0625 =
   201  	// 0.3125, the quantile should be a quarter way between the elements at
   202  	// indices 1 and 2. So 1.7 * 0.75 + 4.3 * 0.25 = 2.35.
   203  	functionConstant = 0.3125
   204  	val, err = reduceRunningEntries(entries, segutils.Quantile, functionConstant)
   205  	assert.Nil(t, err)
   206  	assert.True(t, dtypeutils.AlmostEquals(2.35, val))
   207  
   208  	// Cardinality is not implemented yet, so this should error.
   209  	_, err = reduceRunningEntries(entries, segutils.Cardinality, functionConstant)
   210  	assert.NotNil(t, err)
   211  }