github.com/argoproj/argo-cd/v3@v3.2.1/util/argo/diff/ignore_test.go (about)

     1  package diff_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  
     9  	"github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
    10  	"github.com/argoproj/argo-cd/v3/util/argo/diff"
    11  )
    12  
    13  func TestIgnoreDiffConfig_HasIgnoreDifference(t *testing.T) {
    14  	getOverride := func(gk string) map[string]v1alpha1.ResourceOverride {
    15  		return map[string]v1alpha1.ResourceOverride{
    16  			gk: {
    17  				IgnoreDifferences: v1alpha1.OverrideIgnoreDiff{
    18  					ManagedFieldsManagers: []string{"manager1", "manager2"},
    19  					JQPathExpressions:     []string{"some.jq.path.expr"},
    20  					JSONPointers:          []string{"some.json.pointer"},
    21  				},
    22  			},
    23  		}
    24  	}
    25  	getIgnoreDiff := func(group, kind, name, namespace string) v1alpha1.ResourceIgnoreDifferences {
    26  		return v1alpha1.ResourceIgnoreDifferences{
    27  			Group:                 group,
    28  			Kind:                  kind,
    29  			Name:                  name,
    30  			Namespace:             namespace,
    31  			JSONPointers:          []string{"ignore.diff.json.pointer"},
    32  			JQPathExpressions:     []string{"ignore.diff.jq.path"},
    33  			ManagedFieldsManagers: []string{"ignoreDiffManager1", "ignoreDiffManager2"},
    34  		}
    35  	}
    36  	t.Run("will return ignore diffs from resource override", func(t *testing.T) {
    37  		// given
    38  		gk := "apps/Deployment"
    39  		override := getOverride(gk)
    40  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "", "")
    41  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
    42  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, override)
    43  		expectedManagedFields := append(override[gk].IgnoreDifferences.ManagedFieldsManagers, ignoreDiff.ManagedFieldsManagers...)
    44  		expectedJSONPointers := append(override[gk].IgnoreDifferences.JSONPointers, ignoreDiff.JSONPointers...)
    45  		expectedJQExpression := append(override[gk].IgnoreDifferences.JQPathExpressions, ignoreDiff.JQPathExpressions...)
    46  
    47  		// when
    48  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "default")
    49  
    50  		// then
    51  		assert.True(t, ok)
    52  		assert.NotNil(t, actual)
    53  		assert.Equal(t, expectedManagedFields, actual.ManagedFieldsManagers)
    54  		assert.Equal(t, expectedJSONPointers, actual.JSONPointers)
    55  		assert.Equal(t, expectedJQExpression, actual.JQPathExpressions)
    56  	})
    57  	t.Run("will return ignore diffs from resource override with wildcard", func(t *testing.T) {
    58  		// given
    59  		gk := "*/*"
    60  		override := getOverride(gk)
    61  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "", "")
    62  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
    63  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, override)
    64  		expectedManagedFields := append(override[gk].IgnoreDifferences.ManagedFieldsManagers, ignoreDiff.ManagedFieldsManagers...)
    65  		expectedJSONPointers := append(override[gk].IgnoreDifferences.JSONPointers, ignoreDiff.JSONPointers...)
    66  		expectedJQExpression := append(override[gk].IgnoreDifferences.JQPathExpressions, ignoreDiff.JQPathExpressions...)
    67  
    68  		// when
    69  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "default")
    70  
    71  		// then
    72  		assert.True(t, ok)
    73  		assert.NotNil(t, actual)
    74  		assert.Equal(t, expectedManagedFields, actual.ManagedFieldsManagers)
    75  		assert.Equal(t, expectedJSONPointers, actual.JSONPointers)
    76  		assert.Equal(t, expectedJQExpression, actual.JQPathExpressions)
    77  	})
    78  	t.Run("will return ignore diffs from application resource", func(t *testing.T) {
    79  		// given
    80  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "app-name", "default")
    81  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
    82  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
    83  
    84  		// when
    85  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "default")
    86  
    87  		// then
    88  		assert.True(t, ok)
    89  		assert.NotNil(t, actual)
    90  		assert.Equal(t, ignoreDiff.ManagedFieldsManagers, actual.ManagedFieldsManagers)
    91  		assert.Equal(t, ignoreDiff.JSONPointers, actual.JSONPointers)
    92  		assert.Equal(t, ignoreDiff.JQPathExpressions, actual.JQPathExpressions)
    93  	})
    94  	t.Run("will return ignore diffs from application resource with no app name and namespace configured", func(t *testing.T) {
    95  		// given
    96  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "", "")
    97  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
    98  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
    99  
   100  		// when
   101  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "default")
   102  
   103  		// then
   104  		assert.True(t, ok)
   105  		assert.NotNil(t, actual)
   106  		assert.Equal(t, ignoreDiff.ManagedFieldsManagers, actual.ManagedFieldsManagers)
   107  		assert.Equal(t, ignoreDiff.JSONPointers, actual.JSONPointers)
   108  		assert.Equal(t, ignoreDiff.JQPathExpressions, actual.JQPathExpressions)
   109  	})
   110  	t.Run("will return ignore diffs for all resources from group", func(t *testing.T) {
   111  		// given
   112  		ignoreDiff := getIgnoreDiff("apps", "*", "", "")
   113  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
   114  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
   115  
   116  		// when
   117  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "default")
   118  
   119  		// then
   120  		assert.True(t, ok)
   121  		require.NotNil(t, actual)
   122  		assert.Equal(t, ignoreDiff.ManagedFieldsManagers, actual.ManagedFieldsManagers)
   123  		assert.Equal(t, ignoreDiff.JSONPointers, actual.JSONPointers)
   124  		assert.Equal(t, ignoreDiff.JQPathExpressions, actual.JQPathExpressions)
   125  	})
   126  	t.Run("will return ignore diffs for all resources", func(t *testing.T) {
   127  		// given
   128  		ignoreDiff := getIgnoreDiff("*", "*", "", "")
   129  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
   130  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
   131  
   132  		// when
   133  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "default")
   134  
   135  		// then
   136  		assert.True(t, ok)
   137  		require.NotNil(t, actual)
   138  		assert.Equal(t, ignoreDiff.ManagedFieldsManagers, actual.ManagedFieldsManagers)
   139  		assert.Equal(t, ignoreDiff.JSONPointers, actual.JSONPointers)
   140  		assert.Equal(t, ignoreDiff.JQPathExpressions, actual.JQPathExpressions)
   141  	})
   142  	t.Run("no ignore diffs if namespace do not match", func(t *testing.T) {
   143  		// given
   144  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "app-name", "default")
   145  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
   146  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
   147  
   148  		// when
   149  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "another-namespace")
   150  
   151  		// then
   152  		assert.False(t, ok)
   153  		require.Nil(t, actual)
   154  	})
   155  	t.Run("no ignore diffs if name do not match", func(t *testing.T) {
   156  		// given
   157  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "app-name", "default")
   158  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
   159  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
   160  
   161  		// when
   162  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "another-app", "default")
   163  
   164  		// then
   165  		assert.False(t, ok)
   166  		require.Nil(t, actual)
   167  	})
   168  	t.Run("no ignore diffs if resource do not match", func(t *testing.T) {
   169  		// given
   170  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "app-name", "default")
   171  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
   172  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
   173  
   174  		// when
   175  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Service", "app-name", "default")
   176  
   177  		// then
   178  		assert.False(t, ok)
   179  		require.Nil(t, actual)
   180  	})
   181  	t.Run("no ignore diffs if group do not match", func(t *testing.T) {
   182  		// given
   183  		ignoreDiff := getIgnoreDiff("apps", "Deployment", "app-name", "default")
   184  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
   185  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, nil)
   186  
   187  		// when
   188  		ok, actual := ignoreConfig.HasIgnoreDifference("another-group", "Deployment", "app-name", "default")
   189  
   190  		// then
   191  		assert.False(t, ok)
   192  		require.Nil(t, actual)
   193  	})
   194  	t.Run("will merge ignore differences correctly removing duplicated configs", func(t *testing.T) {
   195  		// given
   196  		gk := "*/*"
   197  		override := getOverride(gk)
   198  		ignoreDiff := getIgnoreDiff("*", "*", "", "")
   199  		expectedManagers := append(ignoreDiff.ManagedFieldsManagers, "repeated-manager")
   200  		expectedManagers = append(expectedManagers, override[gk].IgnoreDifferences.ManagedFieldsManagers...)
   201  		expectedJSONPointers := append(ignoreDiff.JSONPointers, "repeated-jsonpointer")
   202  		expectedJSONPointers = append(expectedJSONPointers, override[gk].IgnoreDifferences.JSONPointers...)
   203  		expectedJQPath := append(ignoreDiff.JQPathExpressions, "repeated-jqpath")
   204  		expectedJQPath = append(expectedJQPath, override[gk].IgnoreDifferences.JQPathExpressions...)
   205  		ignoreDiff.ManagedFieldsManagers = append(ignoreDiff.ManagedFieldsManagers, []string{"repeated-manager", "repeated-manager"}...)
   206  		ignoreDiff.JSONPointers = append(ignoreDiff.JSONPointers, []string{"repeated-jsonpointer", "repeated-jsonpointer"}...)
   207  		ignoreDiff.JQPathExpressions = append(ignoreDiff.JQPathExpressions, []string{"repeated-jqpath", "repeated-jqpath"}...)
   208  		ignoreDiffs := []v1alpha1.ResourceIgnoreDifferences{ignoreDiff}
   209  		ignoreConfig := diff.NewIgnoreDiffConfig(ignoreDiffs, override)
   210  
   211  		// when
   212  		ok, actual := ignoreConfig.HasIgnoreDifference("apps", "Deployment", "app-name", "default")
   213  
   214  		// then
   215  		assert.True(t, ok)
   216  		require.NotNil(t, actual)
   217  		assert.ElementsMatch(t, expectedManagers, actual.ManagedFieldsManagers)
   218  		assert.ElementsMatch(t, expectedJSONPointers, actual.JSONPointers)
   219  		assert.ElementsMatch(t, expectedJQPath, actual.JQPathExpressions)
   220  	})
   221  }