github.com/cilium/cilium@v1.16.2/pkg/policy/api/selector_test.go (about)

     1  // SPDX-License-Identifier: Apache-2.0
     2  // Copyright Authors of Cilium
     3  
     4  package api
     5  
     6  import (
     7  	"fmt"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	k8sLbls "github.com/cilium/cilium/pkg/k8s/slim/k8s/apis/labels"
    13  	slim_metav1 "github.com/cilium/cilium/pkg/k8s/slim/k8s/apis/meta/v1"
    14  	"github.com/cilium/cilium/pkg/k8s/slim/k8s/apis/selection"
    15  	"github.com/cilium/cilium/pkg/labels"
    16  )
    17  
    18  func TestSelectsAllEndpoints(t *testing.T) {
    19  	setUpSuite(t)
    20  
    21  	// Empty endpoint selector slice does NOT equate to a wildcard.
    22  	selectorSlice := EndpointSelectorSlice{}
    23  	require.Equal(t, false, selectorSlice.SelectsAllEndpoints())
    24  
    25  	selectorSlice = EndpointSelectorSlice{WildcardEndpointSelector}
    26  	require.Equal(t, true, selectorSlice.SelectsAllEndpoints())
    27  
    28  	// Entity "reserved:all" maps to WildcardEndpointSelector
    29  	selectorSlice = EntitySlice{EntityAll}.GetAsEndpointSelectors()
    30  	require.Equal(t, true, selectorSlice.SelectsAllEndpoints())
    31  
    32  	// Slice that contains wildcard and other selectors still selects all endpoints.
    33  	selectorSlice = EndpointSelectorSlice{WildcardEndpointSelector, NewESFromLabels(labels.ParseSelectLabel("bar"))}
    34  	require.Equal(t, true, selectorSlice.SelectsAllEndpoints())
    35  
    36  	selectorSlice = EndpointSelectorSlice{NewESFromLabels(labels.ParseSelectLabel("bar")), NewESFromLabels(labels.ParseSelectLabel("foo"))}
    37  	require.Equal(t, false, selectorSlice.SelectsAllEndpoints())
    38  }
    39  
    40  func TestLabelSelectorToRequirements(t *testing.T) {
    41  	setUpSuite(t)
    42  
    43  	labelSelector := &slim_metav1.LabelSelector{
    44  		MatchLabels: map[string]string{
    45  			"any.foo": "bar",
    46  			"k8s.baz": "alice",
    47  		},
    48  		MatchExpressions: []slim_metav1.LabelSelectorRequirement{
    49  			{
    50  				Key:      "any.foo",
    51  				Operator: "NotIn",
    52  				Values:   []string{"default"},
    53  			},
    54  		},
    55  	}
    56  
    57  	expRequirements := k8sLbls.Requirements{}
    58  	req, err := k8sLbls.NewRequirement("any.foo", selection.Equals, []string{"bar"})
    59  	require.Nil(t, err)
    60  	expRequirements = append(expRequirements, *req)
    61  	req, err = k8sLbls.NewRequirement("any.foo", selection.NotIn, []string{"default"})
    62  	require.Nil(t, err)
    63  	expRequirements = append(expRequirements, *req)
    64  	req, err = k8sLbls.NewRequirement("k8s.baz", selection.Equals, []string{"alice"})
    65  	require.Nil(t, err)
    66  	expRequirements = append(expRequirements, *req)
    67  
    68  	require.EqualValues(t, &expRequirements, labelSelectorToRequirements(labelSelector))
    69  }
    70  
    71  func benchmarkMatchesSetup(match string, count int) (EndpointSelector, labels.LabelArray) {
    72  	stringLabels := []string{}
    73  	for i := 0; i < count; i++ {
    74  		stringLabels = append(stringLabels, fmt.Sprintf("%d", i))
    75  	}
    76  	lbls := labels.NewLabelsFromModel(stringLabels)
    77  	return NewESFromLabels(lbls.ToSlice()...), labels.ParseLabelArray(match)
    78  }
    79  
    80  func BenchmarkMatchesValid1000(b *testing.B) {
    81  	es, match := benchmarkMatchesSetup("42", 1000)
    82  	b.ResetTimer()
    83  	for i := 0; i < b.N; i++ {
    84  		es.Matches(match)
    85  	}
    86  }
    87  
    88  func BenchmarkMatchesInvalid1000(b *testing.B) {
    89  	es, match := benchmarkMatchesSetup("foo", 1000)
    90  	b.ResetTimer()
    91  	for i := 0; i < b.N; i++ {
    92  		es.Matches(match)
    93  	}
    94  }
    95  
    96  func BenchmarkMatchesValid1000Parallel(b *testing.B) {
    97  	es, match := benchmarkMatchesSetup("42", 1000)
    98  	b.RunParallel(func(pb *testing.PB) {
    99  		for pb.Next() {
   100  			es.Matches(match)
   101  		}
   102  	})
   103  }
   104  
   105  func BenchmarkMatchesInvalid1000Parallel(b *testing.B) {
   106  	es, match := benchmarkMatchesSetup("foo", 1000)
   107  	b.RunParallel(func(pb *testing.PB) {
   108  		for pb.Next() {
   109  			es.Matches(match)
   110  		}
   111  	})
   112  }