github.com/argoproj/argo-cd/v3@v3.2.1/applicationset/controllers/template/patch_test.go (about)

     1  package template
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
     9  
    10  	appv1 "github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
    11  )
    12  
    13  func Test_ApplyTemplatePatch(t *testing.T) {
    14  	testCases := []struct {
    15  		name          string
    16  		appTemplate   *appv1.Application
    17  		templatePatch string
    18  		expectedApp   *appv1.Application
    19  	}{
    20  		{
    21  			name: "patch with JSON",
    22  			appTemplate: &appv1.Application{
    23  				TypeMeta: metav1.TypeMeta{
    24  					Kind:       "Application",
    25  					APIVersion: "argoproj.io/v1alpha1",
    26  				},
    27  				ObjectMeta: metav1.ObjectMeta{
    28  					Name:       "my-cluster-guestbook",
    29  					Namespace:  "namespace",
    30  					Finalizers: []string{appv1.ResourcesFinalizerName},
    31  				},
    32  				Spec: appv1.ApplicationSpec{
    33  					Project: "default",
    34  					Source: &appv1.ApplicationSource{
    35  						RepoURL:        "https://github.com/argoproj/argocd-example-apps.git",
    36  						TargetRevision: "HEAD",
    37  						Path:           "guestbook",
    38  					},
    39  					Destination: appv1.ApplicationDestination{
    40  						Server:    "https://kubernetes.default.svc",
    41  						Namespace: "guestbook",
    42  					},
    43  				},
    44  			},
    45  			templatePatch: `{
    46  				"metadata": {
    47  					"annotations": {
    48  						"annotation-some-key": "annotation-some-value"
    49  					}
    50  				},
    51  				"spec": {
    52  					"source": {
    53  						"helm": {
    54  							"valueFiles": [
    55  								"values.test.yaml",
    56  								"values.big.yaml"
    57  							]
    58  						}
    59  					},
    60  					"syncPolicy": {
    61  						"automated": {
    62  							"prune": true
    63  						}
    64  					}
    65  				}
    66  			}`,
    67  			expectedApp: &appv1.Application{
    68  				TypeMeta: metav1.TypeMeta{
    69  					Kind:       "Application",
    70  					APIVersion: "argoproj.io/v1alpha1",
    71  				},
    72  				ObjectMeta: metav1.ObjectMeta{
    73  					Name:       "my-cluster-guestbook",
    74  					Namespace:  "namespace",
    75  					Finalizers: []string{appv1.ResourcesFinalizerName},
    76  					Annotations: map[string]string{
    77  						"annotation-some-key": "annotation-some-value",
    78  					},
    79  				},
    80  				Spec: appv1.ApplicationSpec{
    81  					Project: "default",
    82  					Source: &appv1.ApplicationSource{
    83  						RepoURL:        "https://github.com/argoproj/argocd-example-apps.git",
    84  						TargetRevision: "HEAD",
    85  						Path:           "guestbook",
    86  						Helm: &appv1.ApplicationSourceHelm{
    87  							ValueFiles: []string{
    88  								"values.test.yaml",
    89  								"values.big.yaml",
    90  							},
    91  						},
    92  					},
    93  					Destination: appv1.ApplicationDestination{
    94  						Server:    "https://kubernetes.default.svc",
    95  						Namespace: "guestbook",
    96  					},
    97  					SyncPolicy: &appv1.SyncPolicy{
    98  						Automated: &appv1.SyncPolicyAutomated{
    99  							Prune: true,
   100  						},
   101  					},
   102  				},
   103  			},
   104  		},
   105  		{
   106  			name: "patch with YAML",
   107  			appTemplate: &appv1.Application{
   108  				TypeMeta: metav1.TypeMeta{
   109  					Kind:       "Application",
   110  					APIVersion: "argoproj.io/v1alpha1",
   111  				},
   112  				ObjectMeta: metav1.ObjectMeta{
   113  					Name:       "my-cluster-guestbook",
   114  					Namespace:  "namespace",
   115  					Finalizers: []string{appv1.ResourcesFinalizerName},
   116  				},
   117  				Spec: appv1.ApplicationSpec{
   118  					Project: "default",
   119  					Source: &appv1.ApplicationSource{
   120  						RepoURL:        "https://github.com/argoproj/argocd-example-apps.git",
   121  						TargetRevision: "HEAD",
   122  						Path:           "guestbook",
   123  					},
   124  					Destination: appv1.ApplicationDestination{
   125  						Server:    "https://kubernetes.default.svc",
   126  						Namespace: "guestbook",
   127  					},
   128  				},
   129  			},
   130  			templatePatch: `
   131  metadata:
   132    annotations:
   133      annotation-some-key: annotation-some-value
   134  spec:
   135    source:
   136      helm:
   137        valueFiles:
   138          - values.test.yaml
   139          - values.big.yaml
   140    syncPolicy:
   141      automated:
   142        prune: true`,
   143  			expectedApp: &appv1.Application{
   144  				TypeMeta: metav1.TypeMeta{
   145  					Kind:       "Application",
   146  					APIVersion: "argoproj.io/v1alpha1",
   147  				},
   148  				ObjectMeta: metav1.ObjectMeta{
   149  					Name:       "my-cluster-guestbook",
   150  					Namespace:  "namespace",
   151  					Finalizers: []string{appv1.ResourcesFinalizerName},
   152  					Annotations: map[string]string{
   153  						"annotation-some-key": "annotation-some-value",
   154  					},
   155  				},
   156  				Spec: appv1.ApplicationSpec{
   157  					Project: "default",
   158  					Source: &appv1.ApplicationSource{
   159  						RepoURL:        "https://github.com/argoproj/argocd-example-apps.git",
   160  						TargetRevision: "HEAD",
   161  						Path:           "guestbook",
   162  						Helm: &appv1.ApplicationSourceHelm{
   163  							ValueFiles: []string{
   164  								"values.test.yaml",
   165  								"values.big.yaml",
   166  							},
   167  						},
   168  					},
   169  					Destination: appv1.ApplicationDestination{
   170  						Server:    "https://kubernetes.default.svc",
   171  						Namespace: "guestbook",
   172  					},
   173  					SyncPolicy: &appv1.SyncPolicy{
   174  						Automated: &appv1.SyncPolicyAutomated{
   175  							Prune: true,
   176  						},
   177  					},
   178  				},
   179  			},
   180  		},
   181  		{
   182  			name: "project field isn't overwritten",
   183  			appTemplate: &appv1.Application{
   184  				TypeMeta: metav1.TypeMeta{
   185  					Kind:       "Application",
   186  					APIVersion: "argoproj.io/v1alpha1",
   187  				},
   188  				ObjectMeta: metav1.ObjectMeta{
   189  					Name:      "my-cluster-guestbook",
   190  					Namespace: "namespace",
   191  				},
   192  				Spec: appv1.ApplicationSpec{
   193  					Project: "default",
   194  					Source: &appv1.ApplicationSource{
   195  						RepoURL:        "https://github.com/argoproj/argocd-example-apps.git",
   196  						TargetRevision: "HEAD",
   197  						Path:           "guestbook",
   198  					},
   199  					Destination: appv1.ApplicationDestination{
   200  						Server:    "https://kubernetes.default.svc",
   201  						Namespace: "guestbook",
   202  					},
   203  				},
   204  			},
   205  			templatePatch: `
   206  spec:
   207    project: my-project`,
   208  			expectedApp: &appv1.Application{
   209  				TypeMeta: metav1.TypeMeta{
   210  					Kind:       "Application",
   211  					APIVersion: "argoproj.io/v1alpha1",
   212  				},
   213  				ObjectMeta: metav1.ObjectMeta{
   214  					Name:      "my-cluster-guestbook",
   215  					Namespace: "namespace",
   216  				},
   217  				Spec: appv1.ApplicationSpec{
   218  					Project: "default",
   219  					Source: &appv1.ApplicationSource{
   220  						RepoURL:        "https://github.com/argoproj/argocd-example-apps.git",
   221  						TargetRevision: "HEAD",
   222  						Path:           "guestbook",
   223  					},
   224  					Destination: appv1.ApplicationDestination{
   225  						Server:    "https://kubernetes.default.svc",
   226  						Namespace: "guestbook",
   227  					},
   228  				},
   229  			},
   230  		},
   231  	}
   232  
   233  	for _, tc := range testCases {
   234  		tcc := tc
   235  		t.Run(tcc.name, func(t *testing.T) {
   236  			result, err := applyTemplatePatch(tcc.appTemplate, tcc.templatePatch)
   237  			require.NoError(t, err)
   238  			assert.Equal(t, *tcc.expectedApp, *result)
   239  		})
   240  	}
   241  }
   242  
   243  func TestError(t *testing.T) {
   244  	app := &appv1.Application{}
   245  
   246  	result, err := applyTemplatePatch(app, "hello world")
   247  	require.Error(t, err)
   248  	require.Nil(t, result)
   249  }