github.com/iter8-tools/iter8@v1.1.2/controllers/allcontrollers_test.go (about)

     1  package controllers
     2  
     3  import (
     4  	"context"
     5  	"os"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/iter8-tools/iter8/base"
    10  	"github.com/iter8-tools/iter8/base/log"
    11  	"github.com/iter8-tools/iter8/controllers/k8sclient/fake"
    12  	"github.com/stretchr/testify/assert"
    13  	corev1 "k8s.io/api/core/v1"
    14  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    15  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    16  	"k8s.io/apimachinery/pkg/runtime"
    17  	"k8s.io/apimachinery/pkg/runtime/schema"
    18  )
    19  
    20  func TestStart(t *testing.T) {
    21  	// set pod name
    22  	_ = os.Setenv(podNameEnvVariable, "pod-0")
    23  	// set pod namespace
    24  	_ = os.Setenv(podNamespaceEnvVariable, "default")
    25  	// set config file
    26  	_ = os.Setenv(configEnv, base.CompletePath("../", "testdata/controllers/config.yaml"))
    27  
    28  	// make a routemap that manages replicas for deployment
    29  	cm := corev1.ConfigMap{
    30  		TypeMeta: metav1.TypeMeta{
    31  			Kind:       "ConfigMap",
    32  			APIVersion: "v1",
    33  		},
    34  		ObjectMeta: metav1.ObjectMeta{
    35  			Name:      "test",
    36  			Namespace: "default",
    37  			Labels: map[string]string{
    38  				iter8ManagedByLabel: iter8ManagedByValue,
    39  				iter8KindLabel:      iter8KindRoutemapValue,
    40  				iter8VersionLabel:   base.MajorMinor,
    41  			},
    42  		},
    43  		Immutable: base.BoolPointer(true),
    44  		Data: map[string]string{
    45  			"strSpec": `
    46  versions:
    47  - resources:
    48    - gvrShort: deploy
    49      name: test
    50      namespace: default
    51  routingTemplates:
    52    test:
    53      gvrShort: deploy
    54      template: |
    55        apiVersion: apps/v1
    56        kind: Deployment
    57        metadata:
    58          name: test
    59          namespace: default
    60        spec:
    61          replicas: 2
    62  `,
    63  		},
    64  		BinaryData: map[string][]byte{},
    65  	}
    66  
    67  	// make a deployment
    68  	depu := &unstructured.Unstructured{
    69  		Object: map[string]interface{}{
    70  			"apiVersion": "apps/v1",
    71  			"kind":       "Deployment",
    72  			"metadata": map[string]interface{}{
    73  				"name":      "test",
    74  				"namespace": "default",
    75  				"labels": map[string]interface{}{
    76  					iter8WatchLabel: iter8WatchValue,
    77  				},
    78  			},
    79  		},
    80  	}
    81  
    82  	ctx, cancel := context.WithCancel(context.Background())
    83  	defer cancel()
    84  
    85  	client := fake.New([]runtime.Object{&cm}, []runtime.Object{depu})
    86  	err := Start(ctx.Done(), client)
    87  	assert.NoError(t, err)
    88  
    89  	assert.Eventually(t, func() bool {
    90  		// check if the replicas for the deployment changed
    91  		nd, _ := client.FakeDynamicClient.Resource(schema.GroupVersionResource{
    92  			Group:    "apps",
    93  			Version:  "v1",
    94  			Resource: "deployments",
    95  		}).Namespace("default").Get(context.Background(), "test", metav1.GetOptions{})
    96  
    97  		log.Logger.Debug("uns: ", nd)
    98  
    99  		if nd != nil {
   100  			rep, a, b := unstructured.NestedInt64(nd.UnstructuredContent(), "spec", "replicas")
   101  			if !a || b != nil {
   102  				return false
   103  			}
   104  			return assert.Equal(t, int64(2), rep)
   105  		}
   106  
   107  		return false
   108  	}, time.Second*2, time.Millisecond*100)
   109  
   110  	// check if finalizer has been added
   111  	assert.Eventually(t, func() bool {
   112  		nd, _ := client.FakeDynamicClient.Resource(schema.GroupVersionResource{
   113  			Group:    "apps",
   114  			Version:  "v1",
   115  			Resource: "deployments",
   116  		}).Namespace("default").Get(context.Background(), "test", metav1.GetOptions{})
   117  
   118  		log.Logger.Debug("uns: ", nd)
   119  
   120  		if nd != nil {
   121  			finalizers, a, b := unstructured.NestedStringSlice(nd.UnstructuredContent(), "metadata", "finalizers")
   122  			if !a || b != nil {
   123  				return false
   124  			}
   125  			return assert.Contains(t, finalizers, iter8FinalizerStr)
   126  		}
   127  
   128  		return false
   129  	}, time.Second*2, time.Millisecond*100)
   130  }