...

Source file src/edge-infra.dev/pkg/edge/ctlfish/option/config_test.go

Documentation: edge-infra.dev/pkg/edge/ctlfish/option

     1  package option
     2  
     3  import (
     4  	"context"
     5  	"reflect"
     6  	"strings"
     7  	"testing"
     8  
     9  	"edge-infra.dev/pkg/lib/logging"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    13  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    14  	"k8s.io/apimachinery/pkg/runtime"
    15  	"k8s.io/apimachinery/pkg/runtime/schema"
    16  	testclient "k8s.io/client-go/dynamic/fake"
    17  )
    18  
    19  var (
    20  	monitorList = map[string]bool{"v1/deployments.apps": true, "v1/pods": true}
    21  	watchList   = map[string]bool{
    22  		"v1alpha1/stores.edge.ncr.com":                              true,
    23  		"v1beta1/kustomizations.kustomize.toolkit.fluxcd.io":        true,
    24  		"v2beta1/kustomizations.kustomize.toolkit.fluxcd.io":        true,
    25  		"v1beta1/buckets.source.toolkit.fluxcd.io":                  true,
    26  		"v2beta1/helmreleases.helm.toolkit.fluxcd.io":               true,
    27  		"v1beta1/containerclusters.container.cnrm.cloud.google.com": true,
    28  	}
    29  )
    30  
    31  var (
    32  	configmapResource = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "configmaps"}
    33  )
    34  
    35  func newUnstructuredEdgeInfoConfigMap() *unstructured.Unstructured { //nolint: unparam
    36  	return &unstructured.Unstructured{
    37  		Object: map[string]interface{}{
    38  			"apiVersion": "v1",
    39  			"kind":       "ConfigMap",
    40  			"metadata": map[string]interface{}{
    41  				"namespace": "kube-public",
    42  				"name":      "edge-info",
    43  			},
    44  			"data": map[string]interface{}{
    45  				"cluster.edge.id": "d4509107-2f19-4bd7-a323-79fdd33629f9",
    46  			},
    47  		},
    48  	}
    49  }
    50  
    51  func TestGetConfigAllTrue(t *testing.T) {
    52  	logger := logging.NewLogger()
    53  	c := testclient.NewSimpleDynamicClient(runtime.NewScheme())
    54  	_, err := c.Resource(configmapResource).Namespace("kube-public").Create(context.TODO(), newUnstructuredEdgeInfoConfigMap(), metav1.CreateOptions{})
    55  	assert.NoError(t, err)
    56  	config, err := GetConfig("test-config-all", logger, c)
    57  	assert.NoError(t, err)
    58  	assert.True(t, reflect.DeepEqual(config.MonitorResources, monitorList))
    59  	assert.True(t, reflect.DeepEqual(config.WatchResources, watchList))
    60  }
    61  
    62  func TestGetConfigNotFound(t *testing.T) {
    63  	logger := logging.NewLogger()
    64  	c := testclient.NewSimpleDynamicClient(runtime.NewScheme())
    65  	_, err := c.Resource(configmapResource).Namespace("kube-public").Create(context.TODO(), newUnstructuredEdgeInfoConfigMap(), metav1.CreateOptions{})
    66  	assert.NoError(t, err)
    67  	config, err := GetConfig("NO_FILE", logger, c)
    68  	assert.NoError(t, err)
    69  	assert.True(t, reflect.DeepEqual(config.MonitorResources, monitorList))
    70  	assert.True(t, reflect.DeepEqual(config.WatchResources, watchList))
    71  }
    72  
    73  func TestGetConfigAllFalse(t *testing.T) {
    74  	logger := logging.NewLogger()
    75  	c := testclient.NewSimpleDynamicClient(runtime.NewScheme())
    76  	_, err := c.Resource(configmapResource).Namespace("kube-public").Create(context.TODO(), newUnstructuredEdgeInfoConfigMap(), metav1.CreateOptions{})
    77  	assert.NoError(t, err)
    78  	config, err := GetConfig("test-config-all-false", logger, c)
    79  	assert.NoError(t, err)
    80  	assert.ElementsMatch(t, config.MonitorResources, map[string]bool{}, "resource list received from config file does not match expected empty list")
    81  	assert.ElementsMatch(t, config.WatchResources, map[string]bool{}, "filter list received from config file does not match expected empty list")
    82  }
    83  
    84  func TestIntervalSet(t *testing.T) {
    85  	logger := logging.NewLogger()
    86  	c := testclient.NewSimpleDynamicClient(runtime.NewScheme())
    87  	_, err := c.Resource(configmapResource).Namespace("kube-public").Create(context.TODO(), newUnstructuredEdgeInfoConfigMap(), metav1.CreateOptions{})
    88  	assert.NoError(t, err)
    89  	config, err := GetConfig("test-config-all", logger, c)
    90  	assert.NoError(t, err)
    91  	assert.Equal(t, config.Interval, 111, "interval received from config file does not match expected interval value")
    92  }
    93  
    94  func TestIntervalDefault(t *testing.T) {
    95  	logger := logging.NewLogger()
    96  	c := testclient.NewSimpleDynamicClient(runtime.NewScheme())
    97  	_, err := c.Resource(configmapResource).Namespace("kube-public").Create(context.TODO(), newUnstructuredEdgeInfoConfigMap(), metav1.CreateOptions{})
    98  	assert.NoError(t, err)
    99  	config, err := GetConfig("test-config-all-false", logger, c)
   100  	assert.NoError(t, err)
   101  	assert.Equal(t, config.Interval, 600, "interval received from config does not match expected interval value")
   102  }
   103  
   104  func TestMetricConfig_IsExcluded(t *testing.T) {
   105  	logger := logging.NewLogger()
   106  	c := testclient.NewSimpleDynamicClient(runtime.NewScheme())
   107  	_, err := c.Resource(configmapResource).Namespace("kube-public").Create(context.TODO(), newUnstructuredEdgeInfoConfigMap(), metav1.CreateOptions{})
   108  	assert.NoError(t, err)
   109  	config, err := GetConfig("test-config-all", logger, c)
   110  	assert.NoError(t, err)
   111  	for resource := range monitorList {
   112  		gvr := stringToGVR(resource)
   113  		assert.True(t, config.IsMonitored(gvr), "resource %s should be monitored", resource, gvr)
   114  	}
   115  	for resource := range watchList {
   116  		gvr := stringToGVR(resource)
   117  		assert.True(t, config.IsWatched(gvr), "resource %s should be watched", resource)
   118  	}
   119  }
   120  
   121  func TestMetricConfig_IsIncluded(t *testing.T) {
   122  	logger := logging.NewLogger()
   123  	c := testclient.NewSimpleDynamicClient(runtime.NewScheme())
   124  	_, err := c.Resource(configmapResource).Namespace("kube-public").Create(context.TODO(), newUnstructuredEdgeInfoConfigMap(), metav1.CreateOptions{})
   125  	assert.NoError(t, err)
   126  	config, err := GetConfig("test-config-all", logger, c)
   127  	assert.NoError(t, err)
   128  	for resource := range monitorList {
   129  		gvr := stringToGVR(resource)
   130  		assert.True(t, config.IsMonitored(gvr), "resource %s should be monitored", resource, gvr)
   131  	}
   132  	for resource := range watchList {
   133  		gvr := stringToGVR(resource)
   134  		assert.True(t, config.IsWatched(gvr), "resource %s should be watched", resource)
   135  	}
   136  }
   137  
   138  func TestGVRToString(t *testing.T) {
   139  	gvr := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "events"}
   140  	assert.Equal(t, "v1/events", GVRToString(gvr))
   141  
   142  	gvr = schema.GroupVersionResource{
   143  		Group:    "container.cnrm.cloud.google.com",
   144  		Version:  "v1beta1",
   145  		Resource: "containerclusters",
   146  	}
   147  	assert.Equal(t, "v1beta1/containerclusters.container.cnrm.cloud.google.com", GVRToString(gvr))
   148  }
   149  
   150  func stringToGVR(resource string) schema.GroupVersionResource {
   151  	token := strings.Split(resource, "/")
   152  	return schema.ParseGroupResource(token[1]).WithVersion(token[0])
   153  }
   154  

View as plain text