github.com/argoproj/argo-cd/v2@v2.10.9/applicationset/controllers/requeue_after_test.go (about)

     1  package controllers
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	corev1 "k8s.io/api/core/v1"
    10  	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
    11  	"k8s.io/apimachinery/pkg/runtime"
    12  	"k8s.io/apimachinery/pkg/runtime/schema"
    13  	dynfake "k8s.io/client-go/dynamic/fake"
    14  	kubefake "k8s.io/client-go/kubernetes/fake"
    15  	"k8s.io/client-go/tools/record"
    16  	"sigs.k8s.io/controller-runtime/pkg/client/fake"
    17  
    18  	"github.com/argoproj/argo-cd/v2/applicationset/generators"
    19  	"github.com/argoproj/argo-cd/v2/applicationset/services/mocks"
    20  	argov1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
    21  )
    22  
    23  func TestRequeueAfter(t *testing.T) {
    24  	mockServer := &mocks.Repos{}
    25  	ctx := context.Background()
    26  	scheme := runtime.NewScheme()
    27  	err := argov1alpha1.AddToScheme(scheme)
    28  	assert.Nil(t, err)
    29  	gvrToListKind := map[schema.GroupVersionResource]string{{
    30  		Group:    "mallard.io",
    31  		Version:  "v1",
    32  		Resource: "ducks",
    33  	}: "DuckList"}
    34  	appClientset := kubefake.NewSimpleClientset()
    35  	k8sClient := fake.NewClientBuilder().Build()
    36  	duckType := &unstructured.Unstructured{
    37  		Object: map[string]interface{}{
    38  			"apiVersion": "v2quack",
    39  			"kind":       "Duck",
    40  			"metadata": map[string]interface{}{
    41  				"name":      "mightyduck",
    42  				"namespace": "namespace",
    43  				"labels":    map[string]interface{}{"duck": "all-species"},
    44  			},
    45  			"status": map[string]interface{}{
    46  				"decisions": []interface{}{
    47  					map[string]interface{}{
    48  						"clusterName": "staging-01",
    49  					},
    50  					map[string]interface{}{
    51  						"clusterName": "production-01",
    52  					},
    53  				},
    54  			},
    55  		},
    56  	}
    57  	fakeDynClient := dynfake.NewSimpleDynamicClientWithCustomListKinds(runtime.NewScheme(), gvrToListKind, duckType)
    58  
    59  	terminalGenerators := map[string]generators.Generator{
    60  		"List":                    generators.NewListGenerator(),
    61  		"Clusters":                generators.NewClusterGenerator(k8sClient, ctx, appClientset, "argocd"),
    62  		"Git":                     generators.NewGitGenerator(mockServer),
    63  		"SCMProvider":             generators.NewSCMProviderGenerator(fake.NewClientBuilder().WithObjects(&corev1.Secret{}).Build(), generators.SCMAuthProviders{}, "", []string{""}, true),
    64  		"ClusterDecisionResource": generators.NewDuckTypeGenerator(ctx, fakeDynClient, appClientset, "argocd"),
    65  		"PullRequest":             generators.NewPullRequestGenerator(k8sClient, generators.SCMAuthProviders{}, "", []string{""}, true),
    66  	}
    67  
    68  	nestedGenerators := map[string]generators.Generator{
    69  		"List":                    terminalGenerators["List"],
    70  		"Clusters":                terminalGenerators["Clusters"],
    71  		"Git":                     terminalGenerators["Git"],
    72  		"SCMProvider":             terminalGenerators["SCMProvider"],
    73  		"ClusterDecisionResource": terminalGenerators["ClusterDecisionResource"],
    74  		"PullRequest":             terminalGenerators["PullRequest"],
    75  		"Matrix":                  generators.NewMatrixGenerator(terminalGenerators),
    76  		"Merge":                   generators.NewMergeGenerator(terminalGenerators),
    77  	}
    78  
    79  	topLevelGenerators := map[string]generators.Generator{
    80  		"List":                    terminalGenerators["List"],
    81  		"Clusters":                terminalGenerators["Clusters"],
    82  		"Git":                     terminalGenerators["Git"],
    83  		"SCMProvider":             terminalGenerators["SCMProvider"],
    84  		"ClusterDecisionResource": terminalGenerators["ClusterDecisionResource"],
    85  		"PullRequest":             terminalGenerators["PullRequest"],
    86  		"Matrix":                  generators.NewMatrixGenerator(nestedGenerators),
    87  		"Merge":                   generators.NewMergeGenerator(nestedGenerators),
    88  	}
    89  
    90  	client := fake.NewClientBuilder().WithScheme(scheme).Build()
    91  	r := ApplicationSetReconciler{
    92  		Client:     client,
    93  		Scheme:     scheme,
    94  		Recorder:   record.NewFakeRecorder(0),
    95  		Generators: topLevelGenerators,
    96  	}
    97  
    98  	type args struct {
    99  		appset *argov1alpha1.ApplicationSet
   100  	}
   101  	tests := []struct {
   102  		name    string
   103  		args    args
   104  		want    time.Duration
   105  		wantErr assert.ErrorAssertionFunc
   106  	}{
   107  		{name: "Cluster", args: args{appset: &argov1alpha1.ApplicationSet{
   108  			Spec: argov1alpha1.ApplicationSetSpec{
   109  				Generators: []argov1alpha1.ApplicationSetGenerator{{Clusters: &argov1alpha1.ClusterGenerator{}}},
   110  			},
   111  		}}, want: generators.NoRequeueAfter, wantErr: assert.NoError},
   112  		{name: "ClusterMergeNested", args: args{&argov1alpha1.ApplicationSet{
   113  			Spec: argov1alpha1.ApplicationSetSpec{
   114  				Generators: []argov1alpha1.ApplicationSetGenerator{
   115  					{Clusters: &argov1alpha1.ClusterGenerator{}},
   116  					{Merge: &argov1alpha1.MergeGenerator{
   117  						Generators: []argov1alpha1.ApplicationSetNestedGenerator{
   118  							{
   119  								Clusters: &argov1alpha1.ClusterGenerator{},
   120  								Git:      &argov1alpha1.GitGenerator{},
   121  							},
   122  						},
   123  					}},
   124  				},
   125  			},
   126  		}}, want: generators.DefaultRequeueAfterSeconds, wantErr: assert.NoError},
   127  		{name: "ClusterMatrixNested", args: args{&argov1alpha1.ApplicationSet{
   128  			Spec: argov1alpha1.ApplicationSetSpec{
   129  				Generators: []argov1alpha1.ApplicationSetGenerator{
   130  					{Clusters: &argov1alpha1.ClusterGenerator{}},
   131  					{Matrix: &argov1alpha1.MatrixGenerator{
   132  						Generators: []argov1alpha1.ApplicationSetNestedGenerator{
   133  							{
   134  								Clusters: &argov1alpha1.ClusterGenerator{},
   135  								Git:      &argov1alpha1.GitGenerator{},
   136  							},
   137  						},
   138  					}},
   139  				},
   140  			},
   141  		}}, want: generators.DefaultRequeueAfterSeconds, wantErr: assert.NoError},
   142  		{name: "ListGenerator", args: args{appset: &argov1alpha1.ApplicationSet{
   143  			Spec: argov1alpha1.ApplicationSetSpec{
   144  				Generators: []argov1alpha1.ApplicationSetGenerator{{List: &argov1alpha1.ListGenerator{}}},
   145  			},
   146  		}}, want: generators.NoRequeueAfter, wantErr: assert.NoError},
   147  	}
   148  	for _, tt := range tests {
   149  		t.Run(tt.name, func(t *testing.T) {
   150  			assert.Equalf(t, tt.want, r.getMinRequeueAfter(tt.args.appset), "getMinRequeueAfter(%v)", tt.args.appset)
   151  		})
   152  	}
   153  }