resourcewatcher_test.go

Documentation: github.com/GoogleCloudPlatform/k8s-config-connector/pkg/controller/resourcewatcher

     1  // Copyright 2022 Google LLC
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //      http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package resourcewatcher_test
    16  
    17  import (
    18  	"context"
    19  	"errors"
    20  	"fmt"
    21  	"testing"
    22  	"time"
    23  
    24  	"sigs.k8s.io/controller-runtime/pkg/log"
    25  
    26  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/controller/resourcewatcher"
    27  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/k8s"
    28  	corev1 "k8s.io/api/core/v1"
    29  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    30  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    31  	"k8s.io/apimachinery/pkg/runtime"
    32  	"k8s.io/apimachinery/pkg/runtime/schema"
    33  	"k8s.io/apimachinery/pkg/types"
    34  	dynamicfake "k8s.io/client-go/dynamic/fake"
    35  )
    36  
    37  func TestWatchResourceTimeout(t *testing.T) {
    38  	unreadyResourceUnstructured := newResourceUnstructured(newStatus(corev1.ConditionFalse))
    39  	gvk, nn, err := getResourceInformation(unreadyResourceUnstructured)
    40  	if err != nil {
    41  		t.Fatalf("got unexpected error: %v", err)
    42  	}
    43  	fake := dynamicfake.NewSimpleDynamicClient(runtime.NewScheme())
    44  	logger := log.Log.WithName("resourcewatcher-test-timeout")
    45  	watch, err := resourcewatcher.NewWithClient(fake, logger).WatchResource(context.TODO(), nn, gvk)
    46  	if err != nil {
    47  		t.Fatalf("got unexpected error: %v", err)
    48  	}
    49  	ctx, cancel := context.WithTimeout(context.TODO(), time.Second*10)
    50  	defer cancel()
    51  	if err := resourcewatcher.WaitForResourceToBeReadyViaWatch(ctx, watch, logger); !errors.Is(err, context.DeadlineExceeded) {
    52  		t.Fatalf("got error '%v', expected '%v'", err, context.DeadlineExceeded)
    53  	}
    54  }
    55  
    56  func TestWatchResourceSuccess(t *testing.T) {
    57  	readyResourceUnstructured := newResourceUnstructured(newStatus(corev1.ConditionTrue))
    58  	gvk, nn, err := getResourceInformation(readyResourceUnstructured)
    59  	if err != nil {
    60  		t.Fatalf("got unexpected error: %v", err)
    61  	}
    62  	fake := dynamicfake.NewSimpleDynamicClient(runtime.NewScheme())
    63  	logger := log.Log.WithName("resourcewatcher-test-success")
    64  	watch, err := resourcewatcher.NewWithClient(fake, logger).WatchResource(context.TODO(), nn, gvk)
    65  	if err != nil {
    66  		t.Fatalf("got unexpected error: %v", err)
    67  	}
    68  	fake.Resource(k8s.ToGVR(gvk)).
    69  		Namespace(nn.Namespace).
    70  		Create(context.TODO(), readyResourceUnstructured, metav1.CreateOptions{})
    71  	ctx, cancel := context.WithTimeout(context.TODO(), time.Minute)
    72  	defer cancel()
    73  	if err := resourcewatcher.WaitForResourceToBeReadyViaWatch(ctx, watch, logger); err != nil {
    74  		t.Fatalf("got unexpected error: %v", err)
    75  	}
    76  }
    77  
    78  func newResourceUnstructured(status map[string]interface{}) *unstructured.Unstructured {
    79  	u := &unstructured.Unstructured{
    80  		Object: map[string]interface{}{
    81  			"apiVersion": "pubsub.cnrm.cloud.google.com/v1beta1",
    82  			"kind":       "PubSubTopic",
    83  			"metadata": map[string]interface{}{
    84  				"name":      "test_topic",
    85  				"namespace": "test_namespace",
    86  			},
    87  			"spec": map[string]interface{}{
    88  				"resourceID": "pubsubtopic-sample",
    89  			},
    90  		},
    91  	}
    92  	if status != nil {
    93  		u.Object["status"] = status
    94  	}
    95  	return u
    96  }
    97  
    98  func newStatus(readyStatus corev1.ConditionStatus) map[string]interface{} {
    99  	return map[string]interface{}{
   100  		"conditions": []interface{}{
   101  			map[string]interface{}{
   102  				"type":   "Ready",
   103  				"status": string(readyStatus),
   104  			},
   105  		},
   106  	}
   107  }
   108  
   109  func getResourceInformation(u *unstructured.Unstructured) (schema.GroupVersionKind, types.NamespacedName, error) {
   110  	resource, err := k8s.NewResource(u)
   111  	if err != nil {
   112  		return schema.GroupVersionKind{}, types.NamespacedName{}, fmt.Errorf("error creating k8s resource from unstructured: %w", err)
   113  	}
   114  	return resource.GroupVersionKind(), resource.GetNamespacedName(), nil
   115  }
   116
View as plain text