jitter_test.go

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

     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 jitter_test
    16  
    17  import (
    18  	"testing"
    19  	"time"
    20  
    21  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    22  	"k8s.io/apimachinery/pkg/runtime/schema"
    23  
    24  	iamv1beta1 "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/apis/iam/v1beta1"
    25  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/controller/jitter"
    26  	dclmetadata "github.com/GoogleCloudPlatform/k8s-config-connector/pkg/dcl/metadata"
    27  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/k8s"
    28  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/servicemapping/servicemappingloader"
    29  	"github.com/GoogleCloudPlatform/k8s-config-connector/pkg/test"
    30  )
    31  
    32  func TestGenerateTFJitteredReenqueuePeriod(t *testing.T) {
    33  	t.Parallel()
    34  	gvk := schema.GroupVersionKind{
    35  		Group:   "test1.cnrm.cloud.google.com",
    36  		Version: "v1alpha1",
    37  		Kind:    "Test1Foo",
    38  	}
    39  
    40  	smLoader := servicemappingloader.NewFromServiceMappings(test.FakeServiceMappings())
    41  	duration, err := jitter.GenerateJitteredReenqueuePeriod(gvk, smLoader, nil, &unstructured.Unstructured{})
    42  	if err != nil {
    43  		t.Fatalf("got unexpected err %v, expected nil", err)
    44  	}
    45  
    46  	if duration > time.Duration(100)/2*3*time.Second || duration < time.Duration(100)/2*time.Second {
    47  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk)
    48  	}
    49  }
    50  
    51  func TestGenerateDCLJitteredReenqueuePeriod(t *testing.T) {
    52  	t.Parallel()
    53  	gvk := schema.GroupVersionKind{
    54  		Group:   "test2.cnrm.cloud.google.com",
    55  		Version: "v1beta1",
    56  		Kind:    "Test2Bar",
    57  	}
    58  	var desiredIntervalInSeconds uint32 = 100
    59  
    60  	serviceList := []dclmetadata.ServiceMetadata{
    61  		{
    62  			Name:                 "Test2",
    63  			APIVersion:           "v1beta1",
    64  			ServiceNameUsedByDCL: "test2",
    65  			DCLVersion:           "ga",
    66  			Resources: []dclmetadata.Resource{
    67  				{
    68  					Kind:                            "Test2Bar",
    69  					ReconciliationIntervalInSeconds: &desiredIntervalInSeconds,
    70  				},
    71  			},
    72  		},
    73  	}
    74  
    75  	serviceMetadataLoader := dclmetadata.NewFromServiceList(serviceList)
    76  	duration, err := jitter.GenerateJitteredReenqueuePeriod(gvk, nil, serviceMetadataLoader, &unstructured.Unstructured{})
    77  	if err != nil {
    78  		t.Fatalf("got unexpected err %v, expected nil", err)
    79  	}
    80  
    81  	if duration > time.Duration(desiredIntervalInSeconds)/2*3*time.Second || duration < time.Duration(desiredIntervalInSeconds)/2*time.Second {
    82  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk)
    83  	}
    84  }
    85  
    86  func TestGenerateIAMJitteredReenqueuePeriod(t *testing.T) {
    87  	t.Parallel()
    88  	gvk := iamv1beta1.IAMPolicyGVK
    89  
    90  	duration, err := jitter.GenerateJitteredReenqueuePeriod(gvk, nil, nil, &unstructured.Unstructured{})
    91  	if err != nil {
    92  		t.Fatalf("got unexpected err %v, expected nil", err)
    93  	}
    94  
    95  	if duration > k8s.MeanReconcileReenqueuePeriod/2*3 || duration < k8s.MeanReconcileReenqueuePeriod/2 {
    96  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk)
    97  	}
    98  }
    99  
   100  func TestGenerateJitteredReenqueuePeriodFromAnnotation(t *testing.T) {
   101  	t.Parallel()
   102  	gvk := iamv1beta1.IAMPolicyMemberGVK
   103  	var iamPolicyMember1 iamv1beta1.IAMPolicyMember
   104  	expectedMeanDurition1 := time.Duration(5) * time.Second
   105  	k8s.SetAnnotation(k8s.ReconcileIntervalInSecondsAnnotation, "5", &iamPolicyMember1)
   106  
   107  	var iamPolicyMember2 iamv1beta1.IAMPolicyMember
   108  	k8s.SetAnnotation(k8s.ReconcileIntervalInSecondsAnnotation, "0", &iamPolicyMember2)
   109  
   110  	var iamPolicyMember3 iamv1beta1.IAMPolicyMember
   111  	k8s.SetAnnotation(k8s.ReconcileIntervalInSecondsAnnotation, "1.5", &iamPolicyMember3)
   112  
   113  	duration, err := jitter.GenerateJitteredReenqueuePeriod(gvk, nil, nil, &iamPolicyMember1)
   114  	if err != nil {
   115  		t.Fatalf("got unexpected err %v, expected nil", err)
   116  	}
   117  	if duration > expectedMeanDurition1/2*3 || duration < expectedMeanDurition1/2 {
   118  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk)
   119  	}
   120  
   121  	duration, err = jitter.GenerateJitteredReenqueuePeriod(gvk, nil, nil, &iamPolicyMember2)
   122  	if err != nil {
   123  		t.Fatalf("got unexpected err %v, expected nil", err)
   124  	}
   125  	if duration != 0 {
   126  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk)
   127  	}
   128  
   129  	_, err = jitter.GenerateJitteredReenqueuePeriod(gvk, nil, nil, &iamPolicyMember3)
   130  	if err == nil {
   131  		t.Fatalf("got nil, expected error %v", err)
   132  	}
   133  
   134  }
   135  
   136  func TestGenerateDefaultJitteredReenqueuePeriod(t *testing.T) {
   137  	t.Parallel()
   138  	// gvk1 from TF servicemapping
   139  	gvk1 := schema.GroupVersionKind{
   140  		Group:   "test1.cnrm.cloud.google.com",
   141  		Version: "v1alpha1",
   142  		Kind:    "Test1Bar",
   143  	}
   144  
   145  	// gvk2 from DCL service metadata
   146  	gvk2 := schema.GroupVersionKind{
   147  		Group:   "dcltest1.cnrm.cloud.google.com",
   148  		Version: "v1beta1",
   149  		Kind:    "DclTest2Bar",
   150  	}
   151  
   152  	// gvk3 none TF/DCL
   153  	gvk3 := schema.GroupVersionKind{
   154  		Group:   "foobar.cnrm.cloud.google.com",
   155  		Version: "v1beta1",
   156  		Kind:    "FooBarBaz",
   157  	}
   158  
   159  	smLoader := servicemappingloader.NewFromServiceMappings(test.FakeServiceMappings())
   160  	serviceList := []dclmetadata.ServiceMetadata{
   161  		{
   162  			Name:                 "DclTest1",
   163  			APIVersion:           "v1beta1",
   164  			ServiceNameUsedByDCL: "DclTest1",
   165  			DCLVersion:           "ga",
   166  			Resources: []dclmetadata.Resource{
   167  				{
   168  					Kind: "DclTest1Bar",
   169  				},
   170  			},
   171  		},
   172  	}
   173  
   174  	serviceMetadataLoader := dclmetadata.NewFromServiceList(serviceList)
   175  
   176  	// Test default value for TF resources
   177  	duration, err := jitter.GenerateJitteredReenqueuePeriod(gvk1, smLoader, serviceMetadataLoader, &unstructured.Unstructured{})
   178  	if err != nil {
   179  		t.Fatalf("got unexpected err %v, expected nil", err)
   180  	}
   181  
   182  	if duration > k8s.MeanReconcileReenqueuePeriod/2*3 || duration < k8s.MeanReconcileReenqueuePeriod/2 {
   183  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk1)
   184  	}
   185  
   186  	// Test default value for DCL resources
   187  	duration, err = jitter.GenerateJitteredReenqueuePeriod(gvk2, smLoader, serviceMetadataLoader, &unstructured.Unstructured{})
   188  	if err != nil {
   189  		t.Fatalf("got unexpected err %v, expected nil", err)
   190  	}
   191  
   192  	if duration > k8s.MeanReconcileReenqueuePeriod/2*3 || duration < k8s.MeanReconcileReenqueuePeriod/2 {
   193  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk2)
   194  	}
   195  
   196  	// Test default value for GVK not found in servicemapping/service metadata
   197  	duration, err = jitter.GenerateJitteredReenqueuePeriod(gvk3, smLoader, serviceMetadataLoader, &unstructured.Unstructured{})
   198  	if err != nil {
   199  		t.Fatalf("got unexpected err %v, expected nil", err)
   200  	}
   201  
   202  	if duration > k8s.MeanReconcileReenqueuePeriod/2*3 || duration < k8s.MeanReconcileReenqueuePeriod/2 {
   203  		t.Fatalf("got unexpected time duration %v for gvk %v", duration, gvk2)
   204  	}
   205  }
   206
View as plain text