github.com/cilium/cilium@v1.16.2/operator/pkg/ciliumendpointslice/endpointslice_test.go (about)

     1  // SPDX-License-Identifier: Apache-2.0
     2  // Copyright Authors of Cilium
     3  
     4  package ciliumendpointslice
     5  
     6  import (
     7  	"context"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/cilium/hive/cell"
    12  	"github.com/cilium/hive/hivetest"
    13  	"github.com/stretchr/testify/assert"
    14  
    15  	"github.com/cilium/cilium/operator/k8s"
    16  	tu "github.com/cilium/cilium/operator/pkg/ciliumendpointslice/testutils"
    17  	"github.com/cilium/cilium/pkg/hive"
    18  	cilium_v2 "github.com/cilium/cilium/pkg/k8s/apis/cilium.io/v2"
    19  	cilium_v2a1 "github.com/cilium/cilium/pkg/k8s/apis/cilium.io/v2alpha1"
    20  	k8sClient "github.com/cilium/cilium/pkg/k8s/client"
    21  	"github.com/cilium/cilium/pkg/k8s/resource"
    22  	"github.com/cilium/cilium/pkg/metrics"
    23  )
    24  
    25  func TestFCFSModeSyncCESsInLocalCache(t *testing.T) {
    26  	var r *reconciler
    27  	var fakeClient k8sClient.FakeClientset
    28  	m := newCESManagerFcfs(2, log).(*cesManagerFcfs)
    29  	var ciliumEndpoint resource.Resource[*cilium_v2.CiliumEndpoint]
    30  	var ciliumEndpointSlice resource.Resource[*cilium_v2a1.CiliumEndpointSlice]
    31  	var cesMetrics *Metrics
    32  	hive := hive.New(
    33  		k8sClient.FakeClientCell,
    34  		k8s.ResourcesCell,
    35  		metrics.Metric(NewMetrics),
    36  		cell.Invoke(func(
    37  			c *k8sClient.FakeClientset,
    38  			cep resource.Resource[*cilium_v2.CiliumEndpoint],
    39  			ces resource.Resource[*cilium_v2a1.CiliumEndpointSlice],
    40  			metrics *Metrics,
    41  		) error {
    42  			fakeClient = *c
    43  			ciliumEndpoint = cep
    44  			ciliumEndpointSlice = ces
    45  			cesMetrics = metrics
    46  			return nil
    47  		}),
    48  	)
    49  	tlog := hivetest.Logger(t)
    50  	hive.Start(tlog, context.Background())
    51  	r = newReconciler(context.Background(), fakeClient.CiliumFakeClientset.CiliumV2alpha1(), m, log, ciliumEndpoint, ciliumEndpointSlice, cesMetrics)
    52  	cesStore, _ := ciliumEndpointSlice.Store(context.Background())
    53  	rateLimitConfig, err := getRateLimitConfig(params{Cfg: defaultConfig})
    54  	assert.NoError(t, err)
    55  	cesController := &Controller{
    56  		logger:              log,
    57  		clientset:           fakeClient.Clientset,
    58  		ciliumEndpoint:      ciliumEndpoint,
    59  		ciliumEndpointSlice: ciliumEndpointSlice,
    60  		reconciler:          r,
    61  		manager:             m,
    62  		rateLimit:           rateLimitConfig,
    63  		enqueuedAt:          make(map[CESName]time.Time),
    64  	}
    65  	cesController.initializeQueue()
    66  
    67  	cep1 := tu.CreateManagerEndpoint("cep1", 1)
    68  	cep2 := tu.CreateManagerEndpoint("cep2", 1)
    69  	cep3 := tu.CreateManagerEndpoint("cep3", 2)
    70  	cep4 := tu.CreateManagerEndpoint("cep4", 2)
    71  	ces1 := tu.CreateStoreEndpointSlice("ces1", "ns", []cilium_v2a1.CoreCiliumEndpoint{cep1, cep2, cep3, cep4})
    72  	cesStore.CacheStore().Add(ces1)
    73  	cep5 := tu.CreateManagerEndpoint("cep5", 1)
    74  	cep6 := tu.CreateManagerEndpoint("cep6", 1)
    75  	cep7 := tu.CreateManagerEndpoint("cep7", 2)
    76  	ces2 := tu.CreateStoreEndpointSlice("ces2", "ns", []cilium_v2a1.CoreCiliumEndpoint{cep5, cep6, cep7})
    77  	cesStore.CacheStore().Add(ces2)
    78  
    79  	cesController.syncCESsInLocalCache(context.Background())
    80  
    81  	mapping := m.mapping
    82  
    83  	for _, ces := range []*cilium_v2a1.CiliumEndpointSlice{ces1, ces2} {
    84  		for _, cep := range ces.Endpoints {
    85  			cesN, _ := mapping.getCESName(NewCEPName(cep.Name, "ns"))
    86  			// ensure that the CEP is mapped to the correct CES
    87  			assert.Equal(t, cesN, NewCESName(ces.Name))
    88  		}
    89  	}
    90  
    91  	cesController.queue.ShutDown()
    92  	hive.Stop(tlog, context.Background())
    93  }
    94  
    95  func TestIdentityModeSyncCESsInLocalCache(t *testing.T) {
    96  	var r *reconciler
    97  	var fakeClient k8sClient.FakeClientset
    98  	m := newCESManagerIdentity(2, log).(*cesManagerIdentity)
    99  	var ciliumEndpoint resource.Resource[*cilium_v2.CiliumEndpoint]
   100  	var ciliumEndpointSlice resource.Resource[*cilium_v2a1.CiliumEndpointSlice]
   101  	var cesMetrics *Metrics
   102  	hive := hive.New(
   103  		k8sClient.FakeClientCell,
   104  		k8s.ResourcesCell,
   105  		metrics.Metric(NewMetrics),
   106  		cell.Invoke(func(
   107  			c *k8sClient.FakeClientset,
   108  			cep resource.Resource[*cilium_v2.CiliumEndpoint],
   109  			ces resource.Resource[*cilium_v2a1.CiliumEndpointSlice],
   110  			metrics *Metrics,
   111  		) error {
   112  			fakeClient = *c
   113  			ciliumEndpoint = cep
   114  			ciliumEndpointSlice = ces
   115  			cesMetrics = metrics
   116  			return nil
   117  		}),
   118  	)
   119  	tlog := hivetest.Logger(t)
   120  	hive.Start(tlog, context.Background())
   121  	r = newReconciler(context.Background(), fakeClient.CiliumFakeClientset.CiliumV2alpha1(), m, log, ciliumEndpoint, ciliumEndpointSlice, cesMetrics)
   122  	cesStore, _ := ciliumEndpointSlice.Store(context.Background())
   123  	rateLimitConfig, err := getRateLimitConfig(params{Cfg: defaultConfig})
   124  	assert.NoError(t, err)
   125  	cesController := &Controller{
   126  		logger:              log,
   127  		clientset:           fakeClient.Clientset,
   128  		ciliumEndpoint:      ciliumEndpoint,
   129  		ciliumEndpointSlice: ciliumEndpointSlice,
   130  		reconciler:          r,
   131  		manager:             m,
   132  		rateLimit:           rateLimitConfig,
   133  		enqueuedAt:          make(map[CESName]time.Time),
   134  	}
   135  	cesController.initializeQueue()
   136  
   137  	cep1 := tu.CreateManagerEndpoint("cep1", 1)
   138  	cep2 := tu.CreateManagerEndpoint("cep2", 1)
   139  	cep3 := tu.CreateManagerEndpoint("cep3", 2)
   140  	cep4 := tu.CreateManagerEndpoint("cep4", 2)
   141  	ces1 := tu.CreateStoreEndpointSlice("ces1", "ns", []cilium_v2a1.CoreCiliumEndpoint{cep1, cep2})
   142  	ces2 := tu.CreateStoreEndpointSlice("ces2", "ns", []cilium_v2a1.CoreCiliumEndpoint{cep3, cep4})
   143  	cesStore.CacheStore().Add(ces1)
   144  	cesStore.CacheStore().Add(ces2)
   145  
   146  	cesController.syncCESsInLocalCache(context.Background())
   147  
   148  	mapping := m.mapping
   149  
   150  	for _, ces := range []*cilium_v2a1.CiliumEndpointSlice{ces1, ces2} {
   151  		for _, cep := range ces.Endpoints {
   152  			cesN, _ := mapping.getCESName(NewCEPName(cep.Name, "ns"))
   153  			// ensure that the CEP is mapped to the correct CES
   154  			assert.Equal(t, cesN, NewCESName(ces.Name))
   155  			// ensure that the CES to identity mappings are correct
   156  			assert.Equal(t, m.cesToIdentity[cesN], cep.IdentityID)
   157  			assert.Contains(t, m.identityToCES[cep.IdentityID], cesN)
   158  		}
   159  	}
   160  
   161  	cesController.queue.ShutDown()
   162  	hive.Stop(tlog, context.Background())
   163  }