github.com/verrazzano/verrazzano@v1.7.1/application-operator/controllers/metricsbinding/metricsbinding_utils_test.go (about)

     1  // Copyright (c) 2021, 2022, Oracle and/or its affiliates.
     2  // Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
     3  
     4  package metricsbinding
     5  
     6  import (
     7  	"fmt"
     8  	"os"
     9  	"testing"
    10  
    11  	asserts "github.com/stretchr/testify/assert"
    12  	vzapi "github.com/verrazzano/verrazzano/application-operator/apis/app/v1alpha1"
    13  	vzconst "github.com/verrazzano/verrazzano/pkg/constants"
    14  	"go.uber.org/zap"
    15  	k8sapps "k8s.io/api/apps/v1"
    16  	v1 "k8s.io/api/core/v1"
    17  	k8net "k8s.io/api/networking/v1"
    18  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    19  	"k8s.io/apimachinery/pkg/runtime"
    20  	"sigs.k8s.io/controller-runtime/pkg/client"
    21  )
    22  
    23  const (
    24  	testConfigMapName            = "test-cm-name"
    25  	testDeploymentName           = "test-deployment"
    26  	testDeploymentUID            = "test-uid"
    27  	testMetricsTemplateNamespace = "test-namespace"
    28  	testMetricsTemplateName      = "test-template-name"
    29  	testMetricsBindingNamespace  = "test-namespace"
    30  	testMetricsBindingName       = "test-binding-name"
    31  	deploymentKind               = "Deployment"
    32  	deploymentGroup              = "apps"
    33  	deploymentVersion            = "v1"
    34  )
    35  
    36  // TestCreateJobName tests the job name creator
    37  // GIVEN a set of names
    38  // WHEN the function is invoked
    39  // THEN verify the name is correctly given
    40  func TestCreateJobName(t *testing.T) {
    41  	assert := asserts.New(t)
    42  	assert.Equal(fmt.Sprintf("%s_%s_%s_%s_%s", testMetricsBindingNamespace, testDeploymentName, deploymentGroup, deploymentVersion, deploymentKind), createJobName(metricsBinding))
    43  }
    44  
    45  // TestGetConfigData tests the data retrieval from a
    46  // GIVEN a set of names
    47  // WHEN the function is invoked
    48  // THEN verify the name is correctly given
    49  func TestGetConfigData(t *testing.T) {
    50  	assert := asserts.New(t)
    51  	// Test normal config
    52  	configMap, err := getConfigMapFromTestFile(true)
    53  	assert.NoError(err, "Could not get test file")
    54  	config, err := getConfigData(configMap)
    55  	assert.NoError(err, "Could not create ConfigMap data")
    56  	assert.NotNil(config)
    57  
    58  	// Test empty config
    59  	configMap = &v1.ConfigMap{Data: map[string]string{"prometheus.yml": ""}}
    60  	config, err = getConfigData(configMap)
    61  	assert.NoError(err, "Could not create empty ConfigMap data")
    62  	assert.NotNil(config)
    63  
    64  	// Test data does not exist
    65  	configMap = &v1.ConfigMap{}
    66  	config, err = getConfigData(configMap)
    67  	assert.Error(err, "Expected error from nil Data")
    68  	assert.Nil(config)
    69  }
    70  
    71  // Returns a configmap from the testdata file
    72  func getConfigMapFromTestFile(empty bool) (*v1.ConfigMap, error) {
    73  	if empty {
    74  		return readConfigMapData("./testdata/cmDataEmpty.yaml")
    75  	}
    76  	return readConfigMapData("./testdata/cmDataFilled.yaml")
    77  }
    78  
    79  func readConfigMapData(filename string) (*v1.ConfigMap, error) {
    80  	configMapData, err := os.ReadFile(filename)
    81  	if err != nil {
    82  		return nil, err
    83  	}
    84  	configMap := v1.ConfigMap{
    85  		ObjectMeta: metav1.ObjectMeta{
    86  			Name:      testConfigMapName,
    87  			Namespace: vzconst.VerrazzanoSystemNamespace,
    88  		},
    89  		Data: map[string]string{
    90  			prometheusConfigKey: string(configMapData),
    91  		},
    92  	}
    93  	return &configMap, nil
    94  }
    95  
    96  // Returns a secret from the testdata file
    97  func getSecretFromTestFile(empty bool) (*v1.Secret, error) {
    98  	var secretData []byte
    99  	var err error
   100  	if empty {
   101  		secretData = []byte{}
   102  	} else {
   103  		secretData, err = os.ReadFile("./testdata/secretDataFilled.yaml")
   104  		if err != nil {
   105  			return nil, err
   106  		}
   107  	}
   108  
   109  	secret := v1.Secret{
   110  		ObjectMeta: metav1.ObjectMeta{
   111  			Namespace: vzconst.PrometheusOperatorNamespace,
   112  			Name:      vzconst.PromAdditionalScrapeConfigsSecretName,
   113  		},
   114  		Data: map[string][]byte{
   115  			prometheusConfigKey: secretData,
   116  		},
   117  	}
   118  	return &secret, nil
   119  }
   120  
   121  // Returns a Metrics Template from the testdata file
   122  func getTemplateTestFile() (*vzapi.MetricsTemplate, error) {
   123  	scrapeConfig, err := os.ReadFile("./testdata/scrape-config-template.yaml")
   124  	if err != nil {
   125  		return nil, err
   126  	}
   127  	template := metricsTemplate.DeepCopy()
   128  	template.Spec.PrometheusConfig.ScrapeConfigTemplate = string(scrapeConfig)
   129  	return template, nil
   130  }
   131  
   132  // newScheme creates a new scheme that includes this package's object to use for testing
   133  func newScheme() *runtime.Scheme {
   134  	scheme := runtime.NewScheme()
   135  	// _ = clientgoscheme.AddToScheme(scheme)
   136  	_ = k8sapps.AddToScheme(scheme)
   137  	//	vzapi.AddToScheme(scheme)
   138  	_ = v1.AddToScheme(scheme)
   139  	//	certapiv1alpha2.AddToScheme(scheme)
   140  	_ = k8net.AddToScheme(scheme)
   141  	return scheme
   142  }
   143  
   144  // newReconciler creates a new reconciler for testing
   145  // c - The Kerberos client to inject into the reconciler
   146  func newReconciler(c client.Client) Reconciler {
   147  	log := zap.S().With("test")
   148  	scheme := newScheme()
   149  	reconciler := Reconciler{
   150  		Client:  c,
   151  		Log:     log,
   152  		Scheme:  scheme,
   153  		Scraper: "istio-system/prometheus",
   154  	}
   155  	return reconciler
   156  }