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

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package selector
     4  
     5  import (
     6  	"fmt"
     7  	"testing"
     8  
     9  	"github.com/netdata/go.d.plugin/pkg/matcher"
    10  
    11  	"github.com/prometheus/prometheus/model/labels"
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  func TestParse(t *testing.T) {
    16  	tests := map[string]struct {
    17  		input       string
    18  		expectedSr  Selector
    19  		expectedErr bool
    20  	}{
    21  		"sp op: only metric name": {
    22  			input:      "go_memstats_alloc_bytes !go_memstats_* *",
    23  			expectedSr: mustSPName("go_memstats_alloc_bytes !go_memstats_* *"),
    24  		},
    25  		"string op: metric name with labels": {
    26  			input: fmt.Sprintf(`go_memstats_*{label%s"value"}`, OpEqual),
    27  			expectedSr: andSelector{
    28  				lhs: mustSPName("go_memstats_*"),
    29  				rhs: mustString("label", "value"),
    30  			},
    31  		},
    32  		"neg string op: metric name with labels": {
    33  			input: fmt.Sprintf(`go_memstats_*{label%s"value"}`, OpNegEqual),
    34  			expectedSr: andSelector{
    35  				lhs: mustSPName("go_memstats_*"),
    36  				rhs: Not(mustString("label", "value")),
    37  			},
    38  		},
    39  		"regexp op: metric name with labels": {
    40  			input: fmt.Sprintf(`go_memstats_*{label%s"valu.+"}`, OpRegexp),
    41  			expectedSr: andSelector{
    42  				lhs: mustSPName("go_memstats_*"),
    43  				rhs: mustRegexp("label", "valu.+"),
    44  			},
    45  		},
    46  		"neg regexp op: metric name with labels": {
    47  			input: fmt.Sprintf(`go_memstats_*{label%s"valu.+"}`, OpNegRegexp),
    48  			expectedSr: andSelector{
    49  				lhs: mustSPName("go_memstats_*"),
    50  				rhs: Not(mustRegexp("label", "valu.+")),
    51  			},
    52  		},
    53  		"sp op: metric name with labels": {
    54  			input: fmt.Sprintf(`go_memstats_*{label%s"valu*"}`, OpSimplePatterns),
    55  			expectedSr: andSelector{
    56  				lhs: mustSPName("go_memstats_*"),
    57  				rhs: mustSP("label", "valu*"),
    58  			},
    59  		},
    60  		"neg sp op: metric name with labels": {
    61  			input: fmt.Sprintf(`go_memstats_*{label%s"valu*"}`, OpNegSimplePatterns),
    62  			expectedSr: andSelector{
    63  				lhs: mustSPName("go_memstats_*"),
    64  				rhs: Not(mustSP("label", "valu*")),
    65  			},
    66  		},
    67  		"metric name with several labels": {
    68  			input: fmt.Sprintf(`go_memstats_*{label1%s"value1",label2%s"value2"}`, OpEqual, OpEqual),
    69  			expectedSr: andSelector{
    70  				lhs: andSelector{
    71  					lhs: mustSPName("go_memstats_*"),
    72  					rhs: mustString("label1", "value1"),
    73  				},
    74  				rhs: mustString("label2", "value2"),
    75  			},
    76  		},
    77  		"only labels (unsugar)": {
    78  			input: fmt.Sprintf(`{__name__%s"go_memstats_*",label1%s"value1",label2%s"value2"}`,
    79  				OpSimplePatterns, OpEqual, OpEqual),
    80  			expectedSr: andSelector{
    81  				lhs: andSelector{
    82  					lhs: mustSPName("go_memstats_*"),
    83  					rhs: mustString("label1", "value1"),
    84  				},
    85  				rhs: mustString("label2", "value2"),
    86  			},
    87  		},
    88  	}
    89  
    90  	for name, test := range tests {
    91  		t.Run(name, func(t *testing.T) {
    92  			sr, err := Parse(test.input)
    93  
    94  			if test.expectedErr {
    95  				assert.Error(t, err)
    96  			} else {
    97  				assert.Equal(t, test.expectedSr, sr)
    98  			}
    99  		})
   100  	}
   101  }
   102  
   103  func mustSPName(pattern string) Selector {
   104  	return mustSP(labels.MetricName, pattern)
   105  }
   106  
   107  func mustString(name string, pattern string) Selector {
   108  	return labelSelector{name: name, m: matcher.Must(matcher.NewStringMatcher(pattern, true, true))}
   109  }
   110  
   111  func mustRegexp(name string, pattern string) Selector {
   112  	return labelSelector{name: name, m: matcher.Must(matcher.NewRegExpMatcher(pattern))}
   113  }
   114  
   115  func mustSP(name string, pattern string) Selector {
   116  	return labelSelector{name: name, m: matcher.Must(matcher.NewSimplePatternsMatcher(pattern))}
   117  }