cd/applicationset/services/scm_provider/utils_test.go at main

mirror of https://github.com/hanzoai/cd.git synced 2026-10-30 14:56:45 +00:00

Files

T

zeekay 31c64ef661 test, applicationset: drop Argo branding, fix bugs it was hiding

Rename test names, comments, fixture data, and mock GitHub/webhook
responses that still said Argo/ArgoCD/argocd/argoproj in our own
voice, matching the hanzocd-* binary/configmap names and the
apps.hanzo.ai CRD/annotation domain already established elsewhere
in the fork. Also drop the dated argov1alpha1/argoprojiov1alpha1
import aliases for our own v1alpha1 API package.

Restore the CRD groups a prior blind rename had mangled on a
vendored third-party Argo Workflows example manifest back to the
real argoproj.io, and fix several places where an earlier
half-finished rename had gone silently wrong instead of just being
cosmetic: stale CD_BINARY_NAME values and a stale
--argocd-repo-server flag no longer recognized by the binary, cert
filenames and an ssh_known_hosts alias that didn't match what's
actually on disk, a namespace and a kustomize image substitution
that were silent no-ops, and a test assertion regex that could
never match its own fixture.

External lookup keys we don't control are left byte-exact:
quay.io/argoprojlabs images, the docker.io/argoproj CI builder
image, live argoproj/argo-workflows release URLs, the generated
ArgoprojV1alpha1() clientset method, and the Makefile-coupled
/tmp/argo-e2e and GOPATH mount conventions.

2026-09-05 01:07:59 -07:00

330 lines

6.8 KiB

Go

Raw Permalink Blame History

 package scm_provider
 import (
 	"regexp"
 	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/hanzoai/cd/pkg/apis/application/v1alpha1"
 )
 func TestFilterRepoMatch(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 			},
 			{
 				Repository: "two",
 			},
 			{
 				Repository: "three",
 			},
 			{
 				Repository: "four",
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			RepositoryMatch: new("n|hr"),
 		},
 	}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 2)
 	assert.Equal(t, "one", repos[0].Repository)
 	assert.Equal(t, "three", repos[1].Repository)
 }
 func TestFilterLabelMatch(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 				Labels:     []string{"prod-one", "prod-two", "staging"},
 			},
 			{
 				Repository: "two",
 				Labels:     []string{"prod-two"},
 			},
 			{
 				Repository: "three",
 				Labels:     []string{"staging"},
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			LabelMatch: new("^prod-.*$"),
 		},
 	}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 2)
 	assert.Equal(t, "one", repos[0].Repository)
 	assert.Equal(t, "two", repos[1].Repository)
 }
 func TestFilterPathExists(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 			},
 			{
 				Repository: "two",
 			},
 			{
 				Repository: "three",
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			PathsExist: []string{"two"},
 		},
 	}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 1)
 	assert.Equal(t, "two", repos[0].Repository)
 }
 func TestFilterPathDoesntExists(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 			},
 			{
 				Repository: "two",
 			},
 			{
 				Repository: "three",
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			PathsDoNotExist: []string{"two"},
 		},
 	}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 2)
 }
 func TestFilterRepoMatchBadRegexp(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			RepositoryMatch: new("("),
 		},
 	}
 	_, err := ListRepos(t.Context(), provider, filters, "")
 	require.Error(t, err)
 }
 func TestFilterLabelMatchBadRegexp(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			LabelMatch: new("("),
 		},
 	}
 	_, err := ListRepos(t.Context(), provider, filters, "")
 	require.Error(t, err)
 }
 func TestFilterBranchMatch(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 				Branch:     "one",
 			},
 			{
 				Repository: "one",
 				Branch:     "two",
 			},
 			{
 				Repository: "two",
 				Branch:     "one",
 			},
 			{
 				Repository: "three",
 				Branch:     "one",
 			},
 			{
 				Repository: "three",
 				Branch:     "two",
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			BranchMatch: new("w"),
 		},
 	}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 2)
 	assert.Equal(t, "one", repos[0].Repository)
 	assert.Equal(t, "two", repos[0].Branch)
 	assert.Equal(t, "three", repos[1].Repository)
 	assert.Equal(t, "two", repos[1].Branch)
 }
 func TestMultiFilterAnd(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 				Labels:     []string{"prod-one", "prod-two", "staging"},
 			},
 			{
 				Repository: "two",
 				Labels:     []string{"prod-two"},
 			},
 			{
 				Repository: "three",
 				Labels:     []string{"staging"},
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			RepositoryMatch: new("w"),
 			LabelMatch:      new("^prod-.*$"),
 		},
 	}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 1)
 	assert.Equal(t, "two", repos[0].Repository)
 }
 func TestMultiFilterOr(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 				Labels:     []string{"prod-one", "prod-two", "staging"},
 			},
 			{
 				Repository: "two",
 				Labels:     []string{"prod-two"},
 			},
 			{
 				Repository: "three",
 				Labels:     []string{"staging"},
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{
 		{
 			RepositoryMatch: new("e"),
 		},
 		{
 			LabelMatch: new("^prod-.*$"),
 		},
 	}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 3)
 	assert.Equal(t, "one", repos[0].Repository)
 	assert.Equal(t, "two", repos[1].Repository)
 	assert.Equal(t, "three", repos[2].Repository)
 }
 func TestNoFilters(t *testing.T) {
 	t.Parallel()
 	provider := &MockProvider{
 		Repos: []*Repository{
 			{
 				Repository: "one",
 				Labels:     []string{"prod-one", "prod-two", "staging"},
 			},
 			{
 				Repository: "two",
 				Labels:     []string{"prod-two"},
 			},
 			{
 				Repository: "three",
 				Labels:     []string{"staging"},
 			},
 		},
 	}
 	filters := []v1alpha1.SCMProviderGeneratorFilter{}
 	repos, err := ListRepos(t.Context(), provider, filters, "")
 	require.NoError(t, err)
 	assert.Len(t, repos, 3)
 	assert.Equal(t, "one", repos[0].Repository)
 	assert.Equal(t, "two", repos[1].Repository)
 	assert.Equal(t, "three", repos[2].Repository)
 }
 // tests the getApplicableFilters function, passing in all the filters, and an unset filter, plus an additional
 // branch filter
 func TestApplicableFilterMap(t *testing.T) {
 	t.Parallel()
 	branchFilter := Filter{
 		BranchMatch: &regexp.Regexp{},
 		FilterType:  FilterTypeBranch,
 	}
 	repoFilter := Filter{
 		RepositoryMatch: &regexp.Regexp{},
 		FilterType:      FilterTypeRepo,
 	}
 	pathExistsFilter := Filter{
 		PathsExist: []string{"test"},
 		FilterType: FilterTypeBranch,
 	}
 	pathDoesntExistsFilter := Filter{
 		PathsDoNotExist: []string{"test"},
 		FilterType:      FilterTypeBranch,
 	}
 	labelMatchFilter := Filter{
 		LabelMatch: &regexp.Regexp{},
 		FilterType: FilterTypeRepo,
 	}
 	unsetFilter := Filter{
 		LabelMatch: &regexp.Regexp{},
 	}
 	additionalBranchFilter := Filter{
 		BranchMatch: &regexp.Regexp{},
 		FilterType:  FilterTypeBranch,
 	}
 	filterMap := getApplicableFilters([]*Filter{
 		&branchFilter, &repoFilter,
 		&pathExistsFilter, &labelMatchFilter, &unsetFilter, &additionalBranchFilter, &pathDoesntExistsFilter,
 	})
 	assert.Len(t, filterMap[FilterTypeRepo], 2)
 	assert.Len(t, filterMap[FilterTypeBranch], 4)
 }

330 lines 6.8 KiB Go Raw Permalink Blame History

330 lines

6.8 KiB

Go

Raw Permalink Blame History