github.com/go-graphite/carbonapi@v0.17.0/expr/consolidations/consolidations_test.go (about)

     1  package consolidations
     2  
     3  import (
     4  	"math"
     5  	"testing"
     6  
     7  	"github.com/ansel1/merry"
     8  )
     9  
    10  func TestSummarizeValues(t *testing.T) {
    11  	epsilon := math.Nextafter(1, 2) - 1
    12  	tests := []struct {
    13  		name         string
    14  		function     string
    15  		values       []float64
    16  		xFilesFactor float32
    17  		expected     float64
    18  	}{
    19  		{
    20  			name:         "no values",
    21  			function:     "sum",
    22  			values:       []float64{},
    23  			xFilesFactor: 0,
    24  			expected:     math.NaN(),
    25  		},
    26  		{
    27  			name:         "sum",
    28  			function:     "sum",
    29  			values:       []float64{1, 2, 3},
    30  			xFilesFactor: 0,
    31  			expected:     6,
    32  		},
    33  		{
    34  			name:         "sum alias",
    35  			function:     "total",
    36  			values:       []float64{1, 2, 3},
    37  			xFilesFactor: 0,
    38  			expected:     6,
    39  		},
    40  		{
    41  			name:         "avg",
    42  			function:     "avg",
    43  			values:       []float64{1, 2, 3, 4},
    44  			xFilesFactor: 0,
    45  			expected:     2.5,
    46  		},
    47  		{
    48  			name:         "avg with nones",
    49  			function:     "avg",
    50  			values:       []float64{1, 2, 3, 4, math.NaN()},
    51  			xFilesFactor: 0,
    52  			expected:     2.5,
    53  		},
    54  		{
    55  			name:         "avg xFilesFactor",
    56  			function:     "avg",
    57  			values:       []float64{1, 2, 3, 4, math.NaN()},
    58  			xFilesFactor: 0.9,
    59  			expected:     math.NaN(),
    60  		},
    61  		{
    62  			name:         "max",
    63  			function:     "max",
    64  			values:       []float64{1, 2, 3, 4},
    65  			xFilesFactor: 0,
    66  			expected:     4,
    67  		},
    68  		{
    69  			name:         "min",
    70  			function:     "min",
    71  			values:       []float64{1, 2, 3, 4},
    72  			xFilesFactor: 0,
    73  			expected:     1,
    74  		},
    75  		{
    76  			name:         "last",
    77  			function:     "last",
    78  			values:       []float64{1, 2, 3, 4},
    79  			xFilesFactor: 0,
    80  			expected:     4,
    81  		},
    82  		{
    83  			name:         "range",
    84  			function:     "range",
    85  			values:       []float64{1, 2, 3, 4},
    86  			xFilesFactor: 0,
    87  			expected:     3,
    88  		},
    89  		{
    90  			name:         "median",
    91  			function:     "median",
    92  			values:       []float64{1, 2, 3, 10, 11},
    93  			xFilesFactor: 0,
    94  			expected:     3,
    95  		},
    96  		{
    97  			name:         "multiply",
    98  			function:     "multiply",
    99  			values:       []float64{1, 2, 3, 4},
   100  			xFilesFactor: 0,
   101  			expected:     24,
   102  		},
   103  		{
   104  			name:         "diff",
   105  			function:     "diff",
   106  			values:       []float64{1, 2, 3, 4},
   107  			xFilesFactor: 0,
   108  			expected:     -8,
   109  		},
   110  		{
   111  			name:         "count",
   112  			function:     "count",
   113  			values:       []float64{1, 2, 3, 4},
   114  			xFilesFactor: 0,
   115  			expected:     4,
   116  		},
   117  		{
   118  			name:         "stddev",
   119  			function:     "stddev",
   120  			values:       []float64{1, 2, 3, 4},
   121  			xFilesFactor: 0,
   122  			expected:     1.118033988749895,
   123  		},
   124  		{
   125  			name:         "p50 (fallback)",
   126  			function:     "p50",
   127  			values:       []float64{1, 2, 3, 10, 11},
   128  			xFilesFactor: 0,
   129  			expected:     3,
   130  		},
   131  		{
   132  			name:         "Only NaN",
   133  			function:     "sum",
   134  			values:       []float64{math.NaN(), math.NaN(), math.NaN(), math.NaN()},
   135  			xFilesFactor: 0,
   136  			expected:     math.NaN(),
   137  		},
   138  		{
   139  			name:         "Only 0",
   140  			function:     "sum",
   141  			values:       []float64{0, 0, 0, 0, 0},
   142  			xFilesFactor: 0,
   143  			expected:     0,
   144  		},
   145  	}
   146  
   147  	for _, tt := range tests {
   148  		t.Run(tt.name, func(t *testing.T) {
   149  			actual := SummarizeValues(tt.function, tt.values, tt.xFilesFactor)
   150  			if math.Abs(actual-tt.expected) > epsilon {
   151  				t.Errorf("actual %v, expected %v", actual, tt.expected)
   152  			}
   153  		})
   154  	}
   155  
   156  }
   157  
   158  func TestCheckValidConsolidationFunc(t *testing.T) {
   159  	tests := []struct {
   160  		name           string
   161  		expectedResult error
   162  	}{
   163  		{
   164  			name:           "sum",
   165  			expectedResult: nil,
   166  		},
   167  		{
   168  			name:           "avg",
   169  			expectedResult: nil,
   170  		},
   171  		{
   172  			name:           "p50",
   173  			expectedResult: nil,
   174  		},
   175  		{
   176  			name:           "p99.9",
   177  			expectedResult: nil,
   178  		},
   179  		{
   180  			name:           "test",
   181  			expectedResult: ErrInvalidConsolidationFunc,
   182  		},
   183  	}
   184  
   185  	for _, tt := range tests {
   186  		t.Run(tt.name, func(t *testing.T) {
   187  			result := CheckValidConsolidationFunc(tt.name)
   188  			if result != nil && !merry.Is(result, tt.expectedResult) {
   189  				t.Errorf("actual %v, expected %v", result, tt.expectedResult)
   190  			}
   191  		})
   192  	}
   193  
   194  }