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

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package selector
     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  func TestTrueSelector_Matches(t *testing.T) {
    14  	tests := map[string]struct {
    15  		sr       trueSelector
    16  		lbs      labels.Labels
    17  		expected bool
    18  	}{
    19  		"not empty labels": {
    20  			lbs:      labels.Labels{{Name: labels.MetricName, Value: "name"}},
    21  			expected: true,
    22  		},
    23  		"empty labels": {
    24  			expected: true,
    25  		},
    26  	}
    27  
    28  	for name, test := range tests {
    29  		t.Run(name, func(t *testing.T) {
    30  			if test.expected {
    31  				assert.True(t, test.sr.Matches(test.lbs))
    32  			} else {
    33  				assert.False(t, test.sr.Matches(test.lbs))
    34  			}
    35  		})
    36  	}
    37  }
    38  
    39  func TestFalseSelector_Matches(t *testing.T) {
    40  	tests := map[string]struct {
    41  		sr       falseSelector
    42  		lbs      labels.Labels
    43  		expected bool
    44  	}{
    45  		"not empty labels": {
    46  			lbs:      labels.Labels{{Name: labels.MetricName, Value: "name"}},
    47  			expected: false,
    48  		},
    49  		"empty labels": {
    50  			expected: false,
    51  		},
    52  	}
    53  
    54  	for name, test := range tests {
    55  		t.Run(name, func(t *testing.T) {
    56  			if test.expected {
    57  				assert.True(t, test.sr.Matches(test.lbs))
    58  			} else {
    59  				assert.False(t, test.sr.Matches(test.lbs))
    60  			}
    61  		})
    62  	}
    63  }
    64  
    65  func TestNegSelector_Matches(t *testing.T) {
    66  	tests := map[string]struct {
    67  		sr       negSelector
    68  		lbs      labels.Labels
    69  		expected bool
    70  	}{
    71  		"true matcher": {
    72  			sr:       negSelector{trueSelector{}},
    73  			lbs:      labels.Labels{{Name: labels.MetricName, Value: "name"}},
    74  			expected: false,
    75  		},
    76  		"false matcher": {
    77  			sr:       negSelector{falseSelector{}},
    78  			lbs:      labels.Labels{{Name: labels.MetricName, Value: "name"}},
    79  			expected: true,
    80  		},
    81  	}
    82  
    83  	for name, test := range tests {
    84  		t.Run(name, func(t *testing.T) {
    85  			if test.expected {
    86  				assert.True(t, test.sr.Matches(test.lbs))
    87  			} else {
    88  				assert.False(t, test.sr.Matches(test.lbs))
    89  			}
    90  		})
    91  	}
    92  }
    93  
    94  func TestAndSelector_Matches(t *testing.T) {
    95  	tests := map[string]struct {
    96  		sr       andSelector
    97  		lbs      labels.Labels
    98  		expected bool
    99  	}{
   100  		"true, true": {
   101  			sr:       andSelector{lhs: trueSelector{}, rhs: trueSelector{}},
   102  			expected: true,
   103  		},
   104  		"true, false": {
   105  			sr:       andSelector{lhs: trueSelector{}, rhs: falseSelector{}},
   106  			expected: false,
   107  		},
   108  		"false, true": {
   109  			sr:       andSelector{lhs: trueSelector{}, rhs: falseSelector{}},
   110  			expected: false,
   111  		},
   112  		"false, false": {
   113  			sr:       andSelector{lhs: falseSelector{}, rhs: falseSelector{}},
   114  			expected: false,
   115  		},
   116  	}
   117  
   118  	for name, test := range tests {
   119  		t.Run(name, func(t *testing.T) {
   120  			assert.Equal(t, test.expected, test.sr.Matches(test.lbs))
   121  		})
   122  	}
   123  }
   124  
   125  func TestOrSelector_Matches(t *testing.T) {
   126  	tests := map[string]struct {
   127  		sr       orSelector
   128  		lbs      labels.Labels
   129  		expected bool
   130  	}{
   131  		"true, true": {
   132  			sr:       orSelector{lhs: trueSelector{}, rhs: trueSelector{}},
   133  			expected: true,
   134  		},
   135  		"true, false": {
   136  			sr:       orSelector{lhs: trueSelector{}, rhs: falseSelector{}},
   137  			expected: true,
   138  		},
   139  		"false, true": {
   140  			sr:       orSelector{lhs: trueSelector{}, rhs: falseSelector{}},
   141  			expected: true,
   142  		},
   143  		"false, false": {
   144  			sr:       orSelector{lhs: falseSelector{}, rhs: falseSelector{}},
   145  			expected: false,
   146  		},
   147  	}
   148  
   149  	for name, test := range tests {
   150  		t.Run(name, func(t *testing.T) {
   151  			assert.Equal(t, test.expected, test.sr.Matches(test.lbs))
   152  		})
   153  	}
   154  }
   155  
   156  func Test_And(t *testing.T) {
   157  	tests := map[string]struct {
   158  		srs      []Selector
   159  		expected Selector
   160  	}{
   161  		"2 selectors": {
   162  			srs: []Selector{trueSelector{}, trueSelector{}},
   163  			expected: andSelector{
   164  				lhs: trueSelector{},
   165  				rhs: trueSelector{},
   166  			},
   167  		},
   168  		"4 selectors": {
   169  			srs: []Selector{trueSelector{}, trueSelector{}, trueSelector{}, trueSelector{}},
   170  			expected: andSelector{
   171  				lhs: andSelector{
   172  					lhs: andSelector{
   173  						lhs: trueSelector{},
   174  						rhs: trueSelector{},
   175  					},
   176  					rhs: trueSelector{},
   177  				},
   178  				rhs: trueSelector{}},
   179  		},
   180  	}
   181  
   182  	for name, test := range tests {
   183  		t.Run(name, func(t *testing.T) {
   184  			require.GreaterOrEqual(t, len(test.srs), 2)
   185  
   186  			s := And(test.srs[0], test.srs[1], test.srs[2:]...)
   187  			assert.Equal(t, test.expected, s)
   188  		})
   189  	}
   190  }
   191  
   192  func Test_Or(t *testing.T) {
   193  	tests := map[string]struct {
   194  		srs      []Selector
   195  		expected Selector
   196  	}{
   197  		"2 selectors": {
   198  			srs: []Selector{trueSelector{}, trueSelector{}},
   199  			expected: orSelector{
   200  				lhs: trueSelector{},
   201  				rhs: trueSelector{},
   202  			},
   203  		},
   204  		"4 selectors": {
   205  			srs: []Selector{trueSelector{}, trueSelector{}, trueSelector{}, trueSelector{}},
   206  			expected: orSelector{
   207  				lhs: orSelector{
   208  					lhs: orSelector{
   209  						lhs: trueSelector{},
   210  						rhs: trueSelector{},
   211  					},
   212  					rhs: trueSelector{},
   213  				},
   214  				rhs: trueSelector{}},
   215  		},
   216  	}
   217  
   218  	for name, test := range tests {
   219  		t.Run(name, func(t *testing.T) {
   220  			require.GreaterOrEqual(t, len(test.srs), 2)
   221  
   222  			s := Or(test.srs[0], test.srs[1], test.srs[2:]...)
   223  			assert.Equal(t, test.expected, s)
   224  		})
   225  	}
   226  }