karmada/pkg/util/helper/cache_test.go

/*
Copyright 2022 The Karmada Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package helper

import (
	"reflect"
	"testing"

	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/meta"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/dynamic/fake"
	"k8s.io/client-go/kubernetes/scheme"

	"github.com/karmada-io/karmada/pkg/util/fedinformer/genericmanager"
	"github.com/karmada-io/karmada/pkg/util/fedinformer/keys"
)

func TestGetObjectFromCache(t *testing.T) {
	type args struct {
		restMapper meta.RESTMapper
		manager    func(<-chan struct{}) genericmanager.MultiClusterInformerManager
		fedKey     keys.FederatedKey
	}
	tests := []struct {
		name    string
		args    args
		want    *unstructured.Unstructured
		wantErr bool
	}{
		{
			name: "kind not registered",
			args: args{
				restMapper: meta.NewDefaultRESTMapper(nil),
				manager: func(stopCh <-chan struct{}) genericmanager.MultiClusterInformerManager {
					return genericmanager.NewMultiClusterInformerManager(stopCh)
				},
				fedKey: keys.FederatedKey{Cluster: "cluster", ClusterWideKey: keys.ClusterWideKey{
					Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod",
				}},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "cluster manager not found",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.MultiClusterInformerManager {
					return genericmanager.NewMultiClusterInformerManager(stopCh)
				},
				fedKey: keys.FederatedKey{Cluster: "cluster", ClusterWideKey: keys.ClusterWideKey{
					Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod",
				}},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "get from client, and not found",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.MultiClusterInformerManager {
					m := genericmanager.NewMultiClusterInformerManager(stopCh)
					m.ForCluster("cluster", fake.NewSimpleDynamicClient(scheme.Scheme), 0)
					return m
				},
				fedKey: keys.FederatedKey{Cluster: "cluster", ClusterWideKey: keys.ClusterWideKey{
					Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod",
				}},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "get from client, and get success",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.MultiClusterInformerManager {
					m := genericmanager.NewMultiClusterInformerManager(stopCh)
					m.ForCluster("cluster", fake.NewSimpleDynamicClient(scheme.Scheme,
						&corev1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "default"}},
					), 0)
					return m
				},
				fedKey: keys.FederatedKey{Cluster: "cluster", ClusterWideKey: keys.ClusterWideKey{
					Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod",
				}},
			},
			want: &unstructured.Unstructured{Object: map[string]interface{}{
				"apiVersion": "v1", "kind": "Pod",
				"metadata": map[string]interface{}{"name": "pod", "namespace": "default", "creationTimestamp": nil},
				"spec":     map[string]interface{}{"containers": nil},
				"status":   map[string]interface{}{},
			}},
			wantErr: false,
		},
		{
			name: "get from cache, and not found",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(corev1.SchemeGroupVersion.WithKind("Pod"), meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.MultiClusterInformerManager {
					m := genericmanager.NewMultiClusterInformerManager(stopCh)
					m.ForCluster("cluster", fake.NewSimpleDynamicClient(scheme.Scheme), 0).
						Lister(corev1.SchemeGroupVersion.WithResource("pods")) // register pod informer
					m.Start("cluster")
					m.WaitForCacheSync("cluster")
					return m
				},
				fedKey: keys.FederatedKey{Cluster: "cluster", ClusterWideKey: keys.ClusterWideKey{
					Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod",
				}},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "get from cache, and get success",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(corev1.SchemeGroupVersion.WithKind("Pod"), meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.MultiClusterInformerManager {
					m := genericmanager.NewMultiClusterInformerManager(stopCh)
					m.ForCluster("cluster", fake.NewSimpleDynamicClient(scheme.Scheme,
						&corev1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "default"}},
					), 0).Lister(corev1.SchemeGroupVersion.WithResource("pods")) // register pod informer
					m.Start("cluster")
					m.WaitForCacheSync("cluster")
					return m
				},
				fedKey: keys.FederatedKey{Cluster: "cluster", ClusterWideKey: keys.ClusterWideKey{
					Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod",
				}},
			},
			want: &unstructured.Unstructured{Object: map[string]interface{}{
				"apiVersion": "v1", "kind": "Pod",
				"metadata": map[string]interface{}{"name": "pod", "namespace": "default", "creationTimestamp": nil},
				"spec":     map[string]interface{}{"containers": nil},
				"status":   map[string]interface{}{},
			}},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			stopCh := make(chan struct{})
			defer close(stopCh)
			mgr := tt.args.manager(stopCh)
			got, err := GetObjectFromCache(tt.args.restMapper, mgr, tt.args.fedKey)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetObjectFromCache() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("GetObjectFromCache() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGetObjectFromSingleClusterCache(t *testing.T) {
	type args struct {
		restMapper meta.RESTMapper
		manager    func(<-chan struct{}) genericmanager.SingleClusterInformerManager
		cwk        *keys.ClusterWideKey
	}
	tests := []struct {
		name    string
		args    args
		want    *unstructured.Unstructured
		wantErr bool
	}{
		{
			name: "kind not registered",
			args: args{
				restMapper: meta.NewDefaultRESTMapper(nil),
				manager: func(stopCh <-chan struct{}) genericmanager.SingleClusterInformerManager {
					return genericmanager.NewSingleClusterInformerManager(fake.NewSimpleDynamicClient(scheme.Scheme), 0, stopCh)
				},
				cwk: &keys.ClusterWideKey{Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod"},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "get from client, and not found",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.SingleClusterInformerManager {
					return genericmanager.NewSingleClusterInformerManager(fake.NewSimpleDynamicClient(scheme.Scheme), 0, stopCh)
				},
				cwk: &keys.ClusterWideKey{Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod"},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "get from client, and get success",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(schema.GroupVersionKind{Version: "v1", Kind: "Pod"}, meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.SingleClusterInformerManager {
					c := fake.NewSimpleDynamicClient(scheme.Scheme, &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "default"}})
					return genericmanager.NewSingleClusterInformerManager(c, 0, stopCh)
				},
				cwk: &keys.ClusterWideKey{Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod"},
			},
			want: &unstructured.Unstructured{Object: map[string]interface{}{
				"apiVersion": "v1", "kind": "Pod",
				"metadata": map[string]interface{}{"name": "pod", "namespace": "default", "creationTimestamp": nil},
				"spec":     map[string]interface{}{"containers": nil},
				"status":   map[string]interface{}{},
			}},
			wantErr: false,
		},
		{
			name: "get from cache, and not found",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(corev1.SchemeGroupVersion.WithKind("Pod"), meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.SingleClusterInformerManager {
					m := genericmanager.NewSingleClusterInformerManager(fake.NewSimpleDynamicClient(scheme.Scheme), 0, stopCh)
					m.Lister(corev1.SchemeGroupVersion.WithResource("pods")) // register pod informer
					m.Start()
					m.WaitForCacheSync()
					return m
				},
				cwk: &keys.ClusterWideKey{Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod"},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name: "get from cache, and get success",
			args: args{
				restMapper: func() meta.RESTMapper {
					m := meta.NewDefaultRESTMapper([]schema.GroupVersion{corev1.SchemeGroupVersion})
					m.Add(corev1.SchemeGroupVersion.WithKind("Pod"), meta.RESTScopeNamespace)
					return m
				}(),
				manager: func(stopCh <-chan struct{}) genericmanager.SingleClusterInformerManager {
					c := fake.NewSimpleDynamicClient(scheme.Scheme, &corev1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "pod", Namespace: "default"}})
					m := genericmanager.NewSingleClusterInformerManager(c, 0, stopCh)
					m.Lister(corev1.SchemeGroupVersion.WithResource("pods")) // register pod informer
					m.Start()
					m.WaitForCacheSync()
					return m
				},
				cwk: &keys.ClusterWideKey{Version: "v1", Kind: "Pod", Namespace: "default", Name: "pod"},
			},
			want: &unstructured.Unstructured{Object: map[string]interface{}{
				"apiVersion": "v1", "kind": "Pod",
				"metadata": map[string]interface{}{"name": "pod", "namespace": "default", "creationTimestamp": nil},
				"spec":     map[string]interface{}{"containers": nil},
				"status":   map[string]interface{}{},
			}},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			stopCh := make(chan struct{})
			defer close(stopCh)
			mgr := tt.args.manager(stopCh)
			got, err := GetObjectFromSingleClusterCache(tt.args.restMapper, mgr, tt.args.cwk)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetObjectFromCache() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("GetObjectFromCache() got = %v, want %v", got, tt.want)
			}
		})
	}
}