github.com/argoproj/argo-cd/v3@v3.2.1/applicationset/services/scm_provider/utils_test.go (about)

     1  package scm_provider
     2  
     3  import (
     4  	"regexp"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  
    10  	argoprojiov1alpha1 "github.com/argoproj/argo-cd/v3/pkg/apis/application/v1alpha1"
    11  )
    12  
    13  func strp(s string) *string {
    14  	return &s
    15  }
    16  
    17  func TestFilterRepoMatch(t *testing.T) {
    18  	provider := &MockProvider{
    19  		Repos: []*Repository{
    20  			{
    21  				Repository: "one",
    22  			},
    23  			{
    24  				Repository: "two",
    25  			},
    26  			{
    27  				Repository: "three",
    28  			},
    29  			{
    30  				Repository: "four",
    31  			},
    32  		},
    33  	}
    34  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
    35  		{
    36  			RepositoryMatch: strp("n|hr"),
    37  		},
    38  	}
    39  	repos, err := ListRepos(t.Context(), provider, filters, "")
    40  	require.NoError(t, err)
    41  	assert.Len(t, repos, 2)
    42  	assert.Equal(t, "one", repos[0].Repository)
    43  	assert.Equal(t, "three", repos[1].Repository)
    44  }
    45  
    46  func TestFilterLabelMatch(t *testing.T) {
    47  	provider := &MockProvider{
    48  		Repos: []*Repository{
    49  			{
    50  				Repository: "one",
    51  				Labels:     []string{"prod-one", "prod-two", "staging"},
    52  			},
    53  			{
    54  				Repository: "two",
    55  				Labels:     []string{"prod-two"},
    56  			},
    57  			{
    58  				Repository: "three",
    59  				Labels:     []string{"staging"},
    60  			},
    61  		},
    62  	}
    63  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
    64  		{
    65  			LabelMatch: strp("^prod-.*$"),
    66  		},
    67  	}
    68  	repos, err := ListRepos(t.Context(), provider, filters, "")
    69  	require.NoError(t, err)
    70  	assert.Len(t, repos, 2)
    71  	assert.Equal(t, "one", repos[0].Repository)
    72  	assert.Equal(t, "two", repos[1].Repository)
    73  }
    74  
    75  func TestFilterPathExists(t *testing.T) {
    76  	provider := &MockProvider{
    77  		Repos: []*Repository{
    78  			{
    79  				Repository: "one",
    80  			},
    81  			{
    82  				Repository: "two",
    83  			},
    84  			{
    85  				Repository: "three",
    86  			},
    87  		},
    88  	}
    89  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
    90  		{
    91  			PathsExist: []string{"two"},
    92  		},
    93  	}
    94  	repos, err := ListRepos(t.Context(), provider, filters, "")
    95  	require.NoError(t, err)
    96  	assert.Len(t, repos, 1)
    97  	assert.Equal(t, "two", repos[0].Repository)
    98  }
    99  
   100  func TestFilterPathDoesntExists(t *testing.T) {
   101  	provider := &MockProvider{
   102  		Repos: []*Repository{
   103  			{
   104  				Repository: "one",
   105  			},
   106  			{
   107  				Repository: "two",
   108  			},
   109  			{
   110  				Repository: "three",
   111  			},
   112  		},
   113  	}
   114  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
   115  		{
   116  			PathsDoNotExist: []string{"two"},
   117  		},
   118  	}
   119  	repos, err := ListRepos(t.Context(), provider, filters, "")
   120  	require.NoError(t, err)
   121  	assert.Len(t, repos, 2)
   122  }
   123  
   124  func TestFilterRepoMatchBadRegexp(t *testing.T) {
   125  	provider := &MockProvider{
   126  		Repos: []*Repository{
   127  			{
   128  				Repository: "one",
   129  			},
   130  		},
   131  	}
   132  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
   133  		{
   134  			RepositoryMatch: strp("("),
   135  		},
   136  	}
   137  	_, err := ListRepos(t.Context(), provider, filters, "")
   138  	require.Error(t, err)
   139  }
   140  
   141  func TestFilterLabelMatchBadRegexp(t *testing.T) {
   142  	provider := &MockProvider{
   143  		Repos: []*Repository{
   144  			{
   145  				Repository: "one",
   146  			},
   147  		},
   148  	}
   149  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
   150  		{
   151  			LabelMatch: strp("("),
   152  		},
   153  	}
   154  	_, err := ListRepos(t.Context(), provider, filters, "")
   155  	require.Error(t, err)
   156  }
   157  
   158  func TestFilterBranchMatch(t *testing.T) {
   159  	provider := &MockProvider{
   160  		Repos: []*Repository{
   161  			{
   162  				Repository: "one",
   163  				Branch:     "one",
   164  			},
   165  			{
   166  				Repository: "one",
   167  				Branch:     "two",
   168  			},
   169  			{
   170  				Repository: "two",
   171  				Branch:     "one",
   172  			},
   173  			{
   174  				Repository: "three",
   175  				Branch:     "one",
   176  			},
   177  			{
   178  				Repository: "three",
   179  				Branch:     "two",
   180  			},
   181  		},
   182  	}
   183  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
   184  		{
   185  			BranchMatch: strp("w"),
   186  		},
   187  	}
   188  	repos, err := ListRepos(t.Context(), provider, filters, "")
   189  	require.NoError(t, err)
   190  	assert.Len(t, repos, 2)
   191  	assert.Equal(t, "one", repos[0].Repository)
   192  	assert.Equal(t, "two", repos[0].Branch)
   193  	assert.Equal(t, "three", repos[1].Repository)
   194  	assert.Equal(t, "two", repos[1].Branch)
   195  }
   196  
   197  func TestMultiFilterAnd(t *testing.T) {
   198  	provider := &MockProvider{
   199  		Repos: []*Repository{
   200  			{
   201  				Repository: "one",
   202  				Labels:     []string{"prod-one", "prod-two", "staging"},
   203  			},
   204  			{
   205  				Repository: "two",
   206  				Labels:     []string{"prod-two"},
   207  			},
   208  			{
   209  				Repository: "three",
   210  				Labels:     []string{"staging"},
   211  			},
   212  		},
   213  	}
   214  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
   215  		{
   216  			RepositoryMatch: strp("w"),
   217  			LabelMatch:      strp("^prod-.*$"),
   218  		},
   219  	}
   220  	repos, err := ListRepos(t.Context(), provider, filters, "")
   221  	require.NoError(t, err)
   222  	assert.Len(t, repos, 1)
   223  	assert.Equal(t, "two", repos[0].Repository)
   224  }
   225  
   226  func TestMultiFilterOr(t *testing.T) {
   227  	provider := &MockProvider{
   228  		Repos: []*Repository{
   229  			{
   230  				Repository: "one",
   231  				Labels:     []string{"prod-one", "prod-two", "staging"},
   232  			},
   233  			{
   234  				Repository: "two",
   235  				Labels:     []string{"prod-two"},
   236  			},
   237  			{
   238  				Repository: "three",
   239  				Labels:     []string{"staging"},
   240  			},
   241  		},
   242  	}
   243  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{
   244  		{
   245  			RepositoryMatch: strp("e"),
   246  		},
   247  		{
   248  			LabelMatch: strp("^prod-.*$"),
   249  		},
   250  	}
   251  	repos, err := ListRepos(t.Context(), provider, filters, "")
   252  	require.NoError(t, err)
   253  	assert.Len(t, repos, 3)
   254  	assert.Equal(t, "one", repos[0].Repository)
   255  	assert.Equal(t, "two", repos[1].Repository)
   256  	assert.Equal(t, "three", repos[2].Repository)
   257  }
   258  
   259  func TestNoFilters(t *testing.T) {
   260  	provider := &MockProvider{
   261  		Repos: []*Repository{
   262  			{
   263  				Repository: "one",
   264  				Labels:     []string{"prod-one", "prod-two", "staging"},
   265  			},
   266  			{
   267  				Repository: "two",
   268  				Labels:     []string{"prod-two"},
   269  			},
   270  			{
   271  				Repository: "three",
   272  				Labels:     []string{"staging"},
   273  			},
   274  		},
   275  	}
   276  	filters := []argoprojiov1alpha1.SCMProviderGeneratorFilter{}
   277  	repos, err := ListRepos(t.Context(), provider, filters, "")
   278  	require.NoError(t, err)
   279  	assert.Len(t, repos, 3)
   280  	assert.Equal(t, "one", repos[0].Repository)
   281  	assert.Equal(t, "two", repos[1].Repository)
   282  	assert.Equal(t, "three", repos[2].Repository)
   283  }
   284  
   285  // tests the getApplicableFilters function, passing in all the filters, and an unset filter, plus an additional
   286  // branch filter
   287  func TestApplicableFilterMap(t *testing.T) {
   288  	branchFilter := Filter{
   289  		BranchMatch: &regexp.Regexp{},
   290  		FilterType:  FilterTypeBranch,
   291  	}
   292  	repoFilter := Filter{
   293  		RepositoryMatch: &regexp.Regexp{},
   294  		FilterType:      FilterTypeRepo,
   295  	}
   296  	pathExistsFilter := Filter{
   297  		PathsExist: []string{"test"},
   298  		FilterType: FilterTypeBranch,
   299  	}
   300  	pathDoesntExistsFilter := Filter{
   301  		PathsDoNotExist: []string{"test"},
   302  		FilterType:      FilterTypeBranch,
   303  	}
   304  	labelMatchFilter := Filter{
   305  		LabelMatch: &regexp.Regexp{},
   306  		FilterType: FilterTypeRepo,
   307  	}
   308  	unsetFilter := Filter{
   309  		LabelMatch: &regexp.Regexp{},
   310  	}
   311  	additionalBranchFilter := Filter{
   312  		BranchMatch: &regexp.Regexp{},
   313  		FilterType:  FilterTypeBranch,
   314  	}
   315  	filterMap := getApplicableFilters([]*Filter{
   316  		&branchFilter, &repoFilter,
   317  		&pathExistsFilter, &labelMatchFilter, &unsetFilter, &additionalBranchFilter, &pathDoesntExistsFilter,
   318  	})
   319  
   320  	assert.Len(t, filterMap[FilterTypeRepo], 2)
   321  	assert.Len(t, filterMap[FilterTypeBranch], 4)
   322  }