mirror of
https://github.com/hanzoai/deploy.git
synced 2026-10-07 08:44:50 +00:00
41536738c8
* feat(api): hard-fork CRD API group argoproj.io -> deploy.hanzo.ai
Hanzo CD hard-fork, phase 1.1. Single source of truth is
pkg/apis/application/register.go's Group constant (Application/AppProject/
ApplicationSet all derive their FullName from it); every other Go call-site
that hardcoded the literal group string is updated to match: the 3 generated
informer GVRs, the app-of-apps nested-Application detector in types.go, the
resource-tree Application-kind cache populator, the 3 NotFound error
constructors in server/application, and the applicationset-controller's
leader-election Lease name/ID (kept in lockstep across Go source + RBAC
resourceNames, or leader election would get RBAC-denied on startup).
CRD YAMLs (application/appproject/applicationset) and every RBAC apiGroups
rule that actually governs our 3 CRDs are repointed to deploy.hanzo.ai, across
both manifests/base/* (namespaced Roles) and manifests/cluster-rbac/* (cluster
scope). Two adjacent things that share the "argoproj.io" string but are NOT
ours are deliberately left untouched: gitops-engine's health-check dispatch
for Argo Workflows' `Workflow` kind, and argocd-server-clusterrole's second
apiGroups block granting read on Argo Workflows' `workflows` resource — both
belong to a separate, unrelated Argoproj-family project we are not forking.
Also untouched, per explicit scope: annotation/label keys (argocd.argoproj.io/*)
and finalizers (*.argoproj.io) that track already-applied live resources, and
argocd-cm.yaml's resource.customizations.ignoreResourceUpdates keys (a narrow
app-of-apps diffing nicety, not build- or RBAC-relevant).
CGO_ENABLED=0 go build ./... verified green.
* ci: wire canonical hanzo.yml + cicd.yml (Hanzo CD image build)
Phase 1.3. Follows the same one-way pattern every hanzo/lux/zoo repo uses:
hanzo.yml declares the image (root Dockerfile -> ghcr.io/hanzoai/deploy) and a
fast go-build sanity test (the multi-stage Dockerfile build is the slow, real
gate); cicd.yml is the ~10-line trigger shim importing hanzoai/ci's reusable
build workflow on the arc pool, secrets from KMS only.
No `deploy:` block yet, matching the hanzoai/cms build-only-first-cutover
pattern: this repo's own live hanzo-cd namespace runs the whole Hanzo fleet's
GitOps, so the prod image/CRD swap is a deliberate separate action (see the
[HELD] universe PR), never an automatic rollout on merge. Every PR/push still
builds and pushes an immutable ghcr.io/hanzoai/deploy:sha-<7>-amd64 image.
* feat(ui): rebrand Argo CD -> Hanzo CD (title, favicon, logo, sidebar)
Phase 1.2. User-facing "Argo CD"/"ArgoCD" text replaced with "Hanzo CD"
across the login page, help modal, settings screens, version-info panel,
sync-options warning, fullscreen-logs title, app.tsx page titles, and
index.html's <title>/noscript text (dropped the now-wrong upstream CLI
doc link rather than invent a hanzo.ai URL that doesn't exist).
Logo/favicon assets replaced with the canonical Hanzo mark (never
hand-drawn, copied from ~/work/hanzo/logo/dist): the two real usages of
Argo's logo collapse onto one Hanzo glyph (mono + white variants) at the
same 5 call sites (login icon + footer, login.scss $logoPath/
$logoNegativePath, sidebar text-logo), preserving the existing CSS
invert() filters so both the light login panel and dark sidebar still
render correctly. Old argologo.svg/argo_o.svg/argo.png deleted (no
longer referenced). favicon-{16x16,32x32}.png added at
ui/src/assets/favicon/ (index.html's links to that path were previously
dead - the directory didn't exist in this checkout). package.json name
argo-cd-ui -> hanzo-cd-ui.
Left alone, deliberately: the two Kubernetes resource-kind icon sets
under ui/src/assets/images/resources/ (unrelated to branding), and
upstream doc/project links (argoproj.io, argo-cd.readthedocs.io) since
we have no equivalent hanzo.ai docs to point to yet - except the login
footer logo's outbound link, which now points to hanzo.ai instead of
argoproj.io (a Hanzo-branded mark linking to the upstream project it
was forked from read as an obvious leftover).
* feat(module): rename Go module github.com/argoproj/argo-cd/v3 -> github.com/hanzoai/deploy
Phase 2. No version suffix on the new path (org policy: never publish our
own Go modules above v1.x.x / with a v2+ suffix) — this fork starts a fresh
v0/v1 module identity rather than carrying the v3 the upstream fork point
had reached.
Mechanical, symmetric rewrite: 704 .go files (import statements only; two
disjoint substitutions applied specific-first so the nested gitops-engine
module path never double-matches), plus go.mod (module line, the
gitops-engine require+replace pair, version reset to v0.0.0-... since a
suffix-less path can't carry a v3 semver), gitops-engine/go.mod, Makefile
(ldflags PACKAGE + 2 TEST_MODULE filters), .golangci.yaml, .goreleaser.yaml,
.mockery.yaml (+ gitops-engine's), Procfile, the codegen/proto generation
scripts (hack/generate-proto.sh, update-codegen.sh, update-openapi.sh), and
20 .proto files' go_package options. Also one OpenTelemetry tracer name
string in gitops-engine/pkg/sync/sync_context.go (a cosmestic label, not an
import, but worth keeping consistent).
CGO_ENABLED=0 go build ./... verified green for both the root module and
the nested gitops-engine module; go vet clean on both; go mod tidy run
(network available) to reconcile go.sum, dependency set unchanged.
Left alone, deliberately: doc-only mentions (docs/snyk/*.html scan reports,
gitops-engine/README.md), a comment-only reference in
.github/workflows/release.yaml, and one Renovate bot config line — none are
build- or codegen-load-bearing. Also left alone: comments citing upstream
GitHub issue URLs (github.com/argoproj/argo-cd/issues/NNNNN) and a handful
of test fixtures using "https://github.com/argoproj/argo-cd.git" as a
representative example repo URL — both are accurate historical/test-data
references, not stale self-references.
---------
Co-authored-by: Hanzo Dev <[email protected]>
638 lines
25 KiB
Go
638 lines
25 KiB
Go
package util
|
|
|
|
import (
|
|
"log"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/spf13/cobra"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/hanzoai/deploy/pkg/apis/application/v1alpha1"
|
|
|
|
"k8s.io/apimachinery/pkg/util/intstr"
|
|
)
|
|
|
|
func Test_setHelmOpt(t *testing.T) {
|
|
t.Run("Zero", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{})
|
|
assert.Nil(t, src.Helm)
|
|
})
|
|
t.Run("ValueFiles", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{valueFiles: []string{"foo"}})
|
|
assert.Equal(t, []string{"foo"}, src.Helm.ValueFiles)
|
|
})
|
|
t.Run("IgnoreMissingValueFiles", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{ignoreMissingValueFiles: true})
|
|
assert.True(t, src.Helm.IgnoreMissingValueFiles)
|
|
})
|
|
t.Run("ReleaseName", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{releaseName: "foo"})
|
|
assert.Equal(t, "foo", src.Helm.ReleaseName)
|
|
})
|
|
t.Run("HelmSets", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{helmSets: []string{"foo=bar"}})
|
|
assert.Equal(t, []v1alpha1.HelmParameter{{Name: "foo", Value: "bar"}}, src.Helm.Parameters)
|
|
})
|
|
t.Run("HelmSetStrings", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{helmSetStrings: []string{"foo=bar"}})
|
|
assert.Equal(t, []v1alpha1.HelmParameter{{Name: "foo", Value: "bar", ForceString: true}}, src.Helm.Parameters)
|
|
})
|
|
t.Run("HelmSetFiles", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{helmSetFiles: []string{"foo=bar"}})
|
|
assert.Equal(t, []v1alpha1.HelmFileParameter{{Name: "foo", Path: "bar"}}, src.Helm.FileParameters)
|
|
})
|
|
t.Run("Version", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{version: "v3"})
|
|
assert.Equal(t, "v3", src.Helm.Version)
|
|
})
|
|
t.Run("HelmPassCredentials", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{passCredentials: true})
|
|
assert.True(t, src.Helm.PassCredentials)
|
|
})
|
|
t.Run("HelmSkipCrds", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{skipCrds: true})
|
|
assert.True(t, src.Helm.SkipCrds)
|
|
})
|
|
t.Run("HelmSkipSchemaValidation", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{skipSchemaValidation: true})
|
|
assert.True(t, src.Helm.SkipSchemaValidation)
|
|
})
|
|
t.Run("HelmSkipTests", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{skipTests: true})
|
|
assert.True(t, src.Helm.SkipTests)
|
|
})
|
|
t.Run("HelmNamespace", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{namespace: "custom-namespace"})
|
|
assert.Equal(t, "custom-namespace", src.Helm.Namespace)
|
|
})
|
|
t.Run("HelmKubeVersion", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{kubeVersion: "v1.16.0"})
|
|
assert.Equal(t, "v1.16.0", src.Helm.KubeVersion)
|
|
})
|
|
t.Run("HelmApiVersions", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setHelmOpt(&src, helmOpts{apiVersions: []string{"v1", "v2"}})
|
|
assert.Equal(t, []string{"v1", "v2"}, src.Helm.APIVersions)
|
|
})
|
|
}
|
|
|
|
func Test_setKustomizeOpt(t *testing.T) {
|
|
t.Run("No kustomize", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{})
|
|
assert.Nil(t, src.Kustomize)
|
|
})
|
|
t.Run("Name prefix", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{namePrefix: "test-"})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{NamePrefix: "test-"}, src.Kustomize)
|
|
})
|
|
t.Run("Name suffix", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{nameSuffix: "-test"})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{NameSuffix: "-test"}, src.Kustomize)
|
|
})
|
|
t.Run("Images", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{images: []string{"org/image:v1", "org/image:v2"}})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{Images: v1alpha1.KustomizeImages{v1alpha1.KustomizeImage("org/image:v2")}}, src.Kustomize)
|
|
})
|
|
t.Run("Replicas", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
testReplicasString := []string{"my-deployment=2", "my-statefulset=4"}
|
|
testReplicas := v1alpha1.KustomizeReplicas{
|
|
{
|
|
Name: "my-deployment",
|
|
Count: intstr.FromInt(2),
|
|
},
|
|
{
|
|
Name: "my-statefulset",
|
|
Count: intstr.FromInt(4),
|
|
},
|
|
}
|
|
setKustomizeOpt(&src, kustomizeOpts{replicas: testReplicasString})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{Replicas: testReplicas}, src.Kustomize)
|
|
})
|
|
t.Run("Version", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{version: "v0.1"})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{Version: "v0.1"}, src.Kustomize)
|
|
})
|
|
t.Run("Namespace", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{namespace: "custom-namespace"})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{Namespace: "custom-namespace"}, src.Kustomize)
|
|
})
|
|
t.Run("KubeVersion", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{kubeVersion: "999.999.999"})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{KubeVersion: "999.999.999"}, src.Kustomize)
|
|
})
|
|
t.Run("ApiVersions", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{apiVersions: []string{"v1", "v2"}})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{APIVersions: []string{"v1", "v2"}}, src.Kustomize)
|
|
})
|
|
t.Run("Common labels", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{commonLabels: map[string]string{"foo1": "bar1", "foo2": "bar2"}})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{CommonLabels: map[string]string{"foo1": "bar1", "foo2": "bar2"}}, src.Kustomize)
|
|
})
|
|
t.Run("Common annotations", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{commonAnnotations: map[string]string{"foo1": "bar1", "foo2": "bar2"}})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{CommonAnnotations: map[string]string{"foo1": "bar1", "foo2": "bar2"}}, src.Kustomize)
|
|
})
|
|
t.Run("Label Without Selector", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{commonLabels: map[string]string{"foo1": "bar1", "foo2": "bar2"}, labelWithoutSelector: true})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{CommonLabels: map[string]string{"foo1": "bar1", "foo2": "bar2"}, LabelWithoutSelector: true}, src.Kustomize)
|
|
})
|
|
t.Run("Label include templates", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{commonLabels: map[string]string{"foo1": "bar1", "foo2": "bar2"}, labelIncludeTemplates: true})
|
|
assert.Equal(t, &v1alpha1.ApplicationSourceKustomize{CommonLabels: map[string]string{"foo1": "bar1", "foo2": "bar2"}, LabelIncludeTemplates: true}, src.Kustomize)
|
|
})
|
|
t.Run("IgnoreMissingComponents", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setKustomizeOpt(&src, kustomizeOpts{ignoreMissingComponents: true})
|
|
t.Logf("HERE IS THE SOURCE\n %+v\n", src)
|
|
assert.True(t, src.Kustomize.IgnoreMissingComponents)
|
|
})
|
|
}
|
|
|
|
func Test_setJsonnetOpt(t *testing.T) {
|
|
t.Run("TlaSets", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setJsonnetOpt(&src, []string{"foo=bar"}, false)
|
|
assert.Equal(t, []v1alpha1.JsonnetVar{{Name: "foo", Value: "bar"}}, src.Directory.Jsonnet.TLAs)
|
|
setJsonnetOpt(&src, []string{"bar=baz"}, false)
|
|
assert.Equal(t, []v1alpha1.JsonnetVar{{Name: "foo", Value: "bar"}, {Name: "bar", Value: "baz"}}, src.Directory.Jsonnet.TLAs)
|
|
})
|
|
t.Run("ExtSets", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setJsonnetOptExtVar(&src, []string{"foo=bar"}, false)
|
|
assert.Equal(t, []v1alpha1.JsonnetVar{{Name: "foo", Value: "bar"}}, src.Directory.Jsonnet.ExtVars)
|
|
setJsonnetOptExtVar(&src, []string{"bar=baz"}, false)
|
|
assert.Equal(t, []v1alpha1.JsonnetVar{{Name: "foo", Value: "bar"}, {Name: "bar", Value: "baz"}}, src.Directory.Jsonnet.ExtVars)
|
|
})
|
|
}
|
|
|
|
func Test_setPluginOptEnvs(t *testing.T) {
|
|
t.Run("PluginEnvs", func(t *testing.T) {
|
|
src := v1alpha1.ApplicationSource{}
|
|
setPluginOptEnvs(&src, []string{"FOO=bar"})
|
|
assert.Equal(t, v1alpha1.EnvEntry{Name: "FOO", Value: "bar"}, *src.Plugin.Env[0])
|
|
setPluginOptEnvs(&src, []string{"BAR=baz"})
|
|
assert.Equal(t, v1alpha1.EnvEntry{Name: "BAR", Value: "baz"}, *src.Plugin.Env[1])
|
|
setPluginOptEnvs(&src, []string{"FOO=baz"})
|
|
assert.Equal(t, v1alpha1.EnvEntry{Name: "FOO", Value: "baz"}, *src.Plugin.Env[0])
|
|
})
|
|
}
|
|
|
|
type appOptionsFixture struct {
|
|
spec *v1alpha1.ApplicationSpec
|
|
command *cobra.Command
|
|
options *AppOptions
|
|
}
|
|
|
|
func (f *appOptionsFixture) SetFlag(key, value string) error {
|
|
err := f.command.Flags().Set(key, value)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = SetAppSpecOptions(f.command.Flags(), f.spec, f.options, 0)
|
|
return err
|
|
}
|
|
|
|
func (f *appOptionsFixture) SetFlagWithSourcePosition(key, value string, sourcePosition int) error {
|
|
err := f.command.Flags().Set(key, value)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_ = SetAppSpecOptions(f.command.Flags(), f.spec, f.options, sourcePosition)
|
|
return err
|
|
}
|
|
|
|
func newAppOptionsFixture() *appOptionsFixture {
|
|
fixture := &appOptionsFixture{
|
|
spec: &v1alpha1.ApplicationSpec{
|
|
Source: &v1alpha1.ApplicationSource{},
|
|
},
|
|
command: &cobra.Command{},
|
|
options: &AppOptions{},
|
|
}
|
|
AddAppFlags(fixture.command, fixture.options)
|
|
return fixture
|
|
}
|
|
|
|
func Test_setAppSpecOptions(t *testing.T) {
|
|
f := newAppOptionsFixture()
|
|
t.Run("SyncPolicy", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("sync-policy", "automated"))
|
|
assert.NotNil(t, f.spec.SyncPolicy.Automated)
|
|
|
|
f.spec.SyncPolicy = nil
|
|
require.NoError(t, f.SetFlag("sync-policy", "automatic"))
|
|
assert.NotNil(t, f.spec.SyncPolicy.Automated)
|
|
|
|
f.spec.SyncPolicy = nil
|
|
require.NoError(t, f.SetFlag("sync-policy", "auto"))
|
|
assert.NotNil(t, f.spec.SyncPolicy.Automated)
|
|
|
|
require.NoError(t, f.SetFlag("sync-policy", "none"))
|
|
assert.Nil(t, f.spec.SyncPolicy)
|
|
})
|
|
t.Run("SyncOptions", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("sync-option", "a=1"))
|
|
assert.True(t, f.spec.SyncPolicy.SyncOptions.HasOption("a=1"))
|
|
|
|
// remove the options using !
|
|
require.NoError(t, f.SetFlag("sync-option", "!a=1"))
|
|
assert.Nil(t, f.spec.SyncPolicy)
|
|
})
|
|
t.Run("AutoPruneFlag", func(t *testing.T) {
|
|
f := newAppOptionsFixture()
|
|
|
|
// syncPolicy is nil (automated.enabled = false)
|
|
require.NoError(t, f.SetFlag("auto-prune", "true"))
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.Enabled)
|
|
assert.False(t, *f.spec.SyncPolicy.Automated.Enabled)
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.Prune)
|
|
assert.True(t, *f.spec.SyncPolicy.Automated.Prune)
|
|
|
|
// automated.enabled = true
|
|
*f.spec.SyncPolicy.Automated.Enabled = true
|
|
require.NoError(t, f.SetFlag("auto-prune", "false"))
|
|
assert.True(t, *f.spec.SyncPolicy.Automated.Enabled)
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.Prune)
|
|
assert.False(t, *f.spec.SyncPolicy.Automated.Prune)
|
|
})
|
|
t.Run("SelfHealFlag", func(t *testing.T) {
|
|
f := newAppOptionsFixture()
|
|
|
|
require.NoError(t, f.SetFlag("self-heal", "true"))
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.Enabled)
|
|
assert.False(t, *f.spec.SyncPolicy.Automated.Enabled)
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.SelfHeal)
|
|
assert.True(t, *f.spec.SyncPolicy.Automated.SelfHeal)
|
|
|
|
*f.spec.SyncPolicy.Automated.Enabled = true
|
|
require.NoError(t, f.SetFlag("self-heal", "false"))
|
|
assert.True(t, *f.spec.SyncPolicy.Automated.Enabled)
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.SelfHeal)
|
|
assert.False(t, *f.spec.SyncPolicy.Automated.SelfHeal)
|
|
})
|
|
t.Run("AllowEmptyFlag", func(t *testing.T) {
|
|
f := newAppOptionsFixture()
|
|
|
|
require.NoError(t, f.SetFlag("allow-empty", "true"))
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.Enabled)
|
|
assert.False(t, *f.spec.SyncPolicy.Automated.Enabled)
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.AllowEmpty)
|
|
assert.True(t, *f.spec.SyncPolicy.Automated.AllowEmpty)
|
|
|
|
*f.spec.SyncPolicy.Automated.Enabled = true
|
|
require.NoError(t, f.SetFlag("allow-empty", "false"))
|
|
assert.True(t, *f.spec.SyncPolicy.Automated.Enabled)
|
|
require.NotNil(t, f.spec.SyncPolicy.Automated.AllowEmpty)
|
|
assert.False(t, *f.spec.SyncPolicy.Automated.AllowEmpty)
|
|
})
|
|
t.Run("RetryLimit", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("sync-retry-limit", "5"))
|
|
assert.Equal(t, int64(5), f.spec.SyncPolicy.Retry.Limit)
|
|
|
|
require.NoError(t, f.SetFlag("sync-retry-limit", "0"))
|
|
assert.Nil(t, f.spec.SyncPolicy.Retry)
|
|
})
|
|
t.Run("RetryRefresh", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("sync-retry-refresh", "true"))
|
|
assert.True(t, f.spec.SyncPolicy.Retry.Refresh)
|
|
|
|
require.NoError(t, f.SetFlag("sync-retry-refresh", "false"))
|
|
assert.False(t, f.spec.SyncPolicy.Retry.Refresh)
|
|
})
|
|
t.Run("Kustomize", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("kustomize-replica", "my-deployment=2"))
|
|
require.NoError(t, f.SetFlag("kustomize-replica", "my-statefulset=4"))
|
|
assert.Equal(t, v1alpha1.KustomizeReplicas{{Name: "my-deployment", Count: intstr.FromInt(2)}, {Name: "my-statefulset", Count: intstr.FromInt(4)}}, f.spec.Source.Kustomize.Replicas)
|
|
})
|
|
t.Run("Kustomize Namespace", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("kustomize-namespace", "override-namespace"))
|
|
assert.Equal(t, "override-namespace", f.spec.Source.Kustomize.Namespace)
|
|
})
|
|
t.Run("Kustomize Kube Version", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("kustomize-kube-version", "999.999.999"))
|
|
assert.Equal(t, "999.999.999", f.spec.Source.Kustomize.KubeVersion)
|
|
})
|
|
t.Run("Kustomize API Versions", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("kustomize-api-versions", "v1"))
|
|
require.NoError(t, f.SetFlag("kustomize-api-versions", "v2"))
|
|
assert.Equal(t, []string{"v1", "v2"}, f.spec.Source.Kustomize.APIVersions)
|
|
})
|
|
t.Run("Helm Namespace", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("helm-namespace", "override-namespace"))
|
|
assert.Equal(t, "override-namespace", f.spec.Source.Helm.Namespace)
|
|
})
|
|
t.Run("Helm Kube Version", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("kustomize-kube-version", "999.999.999"))
|
|
assert.Equal(t, "999.999.999", f.spec.Source.Kustomize.KubeVersion)
|
|
})
|
|
t.Run("Helm API Versions", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("helm-api-versions", "v1"))
|
|
require.NoError(t, f.SetFlag("helm-api-versions", "v2"))
|
|
assert.Equal(t, []string{"v1", "v2"}, f.spec.Source.Helm.APIVersions)
|
|
})
|
|
t.Run("source hydrator", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlag("dry-source-repo", "https://github.com/argoproj/argocd-example-apps"))
|
|
assert.Equal(t, "https://github.com/argoproj/argocd-example-apps", f.spec.SourceHydrator.DrySource.RepoURL)
|
|
|
|
require.NoError(t, f.SetFlag("dry-source-path", "apps"))
|
|
assert.Equal(t, "apps", f.spec.SourceHydrator.DrySource.Path)
|
|
|
|
require.NoError(t, f.SetFlag("dry-source-revision", "HEAD"))
|
|
assert.Equal(t, "HEAD", f.spec.SourceHydrator.DrySource.TargetRevision)
|
|
|
|
require.NoError(t, f.SetFlag("sync-source-branch", "env/test"))
|
|
assert.Equal(t, "env/test", f.spec.SourceHydrator.SyncSource.TargetBranch)
|
|
|
|
require.NoError(t, f.SetFlag("sync-source-path", "apps"))
|
|
assert.Equal(t, "apps", f.spec.SourceHydrator.SyncSource.Path)
|
|
|
|
require.NoError(t, f.SetFlag("hydrate-to-branch", "env/test-next"))
|
|
assert.Equal(t, "env/test-next", f.spec.SourceHydrator.HydrateTo.TargetBranch)
|
|
|
|
require.NoError(t, f.SetFlag("hydrate-to-branch", ""))
|
|
assert.Nil(t, f.spec.SourceHydrator.HydrateTo)
|
|
})
|
|
}
|
|
|
|
func newMultiSourceAppOptionsFixture() *appOptionsFixture {
|
|
fixture := &appOptionsFixture{
|
|
spec: &v1alpha1.ApplicationSpec{
|
|
Sources: v1alpha1.ApplicationSources{
|
|
v1alpha1.ApplicationSource{},
|
|
v1alpha1.ApplicationSource{},
|
|
},
|
|
},
|
|
command: &cobra.Command{},
|
|
options: &AppOptions{},
|
|
}
|
|
AddAppFlags(fixture.command, fixture.options)
|
|
return fixture
|
|
}
|
|
|
|
func Test_setAppSpecOptionsMultiSourceApp(t *testing.T) {
|
|
f := newMultiSourceAppOptionsFixture()
|
|
sourcePosition := 0
|
|
sourcePosition1 := 1
|
|
sourcePosition2 := 2
|
|
t.Run("SyncPolicy", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlagWithSourcePosition("sync-policy", "automated", sourcePosition1))
|
|
assert.NotNil(t, f.spec.SyncPolicy.Automated)
|
|
|
|
f.spec.SyncPolicy = nil
|
|
require.NoError(t, f.SetFlagWithSourcePosition("sync-policy", "automatic", sourcePosition1))
|
|
assert.NotNil(t, f.spec.SyncPolicy.Automated)
|
|
})
|
|
t.Run("Helm - SourcePosition 0", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlagWithSourcePosition("helm-version", "v2", sourcePosition))
|
|
assert.Len(t, f.spec.GetSources(), 2)
|
|
assert.Equal(t, "v2", f.spec.GetSources()[sourcePosition].Helm.Version)
|
|
})
|
|
t.Run("Kustomize", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlagWithSourcePosition("kustomize-replica", "my-deployment=2", sourcePosition1))
|
|
assert.Equal(t, v1alpha1.KustomizeReplicas{{Name: "my-deployment", Count: intstr.FromInt(2)}}, f.spec.Sources[sourcePosition1-1].Kustomize.Replicas)
|
|
require.NoError(t, f.SetFlagWithSourcePosition("kustomize-replica", "my-deployment=4", sourcePosition2))
|
|
assert.Equal(t, v1alpha1.KustomizeReplicas{{Name: "my-deployment", Count: intstr.FromInt(4)}}, f.spec.Sources[sourcePosition2-1].Kustomize.Replicas)
|
|
})
|
|
t.Run("Helm", func(t *testing.T) {
|
|
require.NoError(t, f.SetFlagWithSourcePosition("helm-version", "v2", sourcePosition1))
|
|
require.NoError(t, f.SetFlagWithSourcePosition("helm-version", "v3", sourcePosition2))
|
|
assert.Len(t, f.spec.GetSources(), 2)
|
|
assert.Equal(t, "v2", f.spec.GetSources()[sourcePosition1-1].Helm.Version)
|
|
assert.Equal(t, "v3", f.spec.GetSources()[sourcePosition2-1].Helm.Version)
|
|
})
|
|
}
|
|
|
|
func Test_setAnnotations(t *testing.T) {
|
|
t.Run("Annotations", func(t *testing.T) {
|
|
app := v1alpha1.Application{}
|
|
setAnnotations(&app, []string{"hoge=foo", "huga=bar"})
|
|
assert.Equal(t, map[string]string{"hoge": "foo", "huga": "bar"}, app.Annotations)
|
|
})
|
|
t.Run("Annotations value contains equal", func(t *testing.T) {
|
|
app := v1alpha1.Application{}
|
|
setAnnotations(&app, []string{"hoge=foo=bar"})
|
|
assert.Equal(t, map[string]string{"hoge": "foo=bar"}, app.Annotations)
|
|
})
|
|
t.Run("Annotations empty value", func(t *testing.T) {
|
|
app := v1alpha1.Application{}
|
|
setAnnotations(&app, []string{"hoge"})
|
|
assert.Equal(t, map[string]string{"hoge": ""}, app.Annotations)
|
|
})
|
|
}
|
|
|
|
const appsYaml = `---
|
|
# Source: apps/templates/helm.yaml
|
|
apiVersion: argoproj.io/v1alpha1
|
|
kind: Application
|
|
metadata:
|
|
name: sth1
|
|
namespace: argocd
|
|
finalizers:
|
|
- resources-finalizer.argocd.argoproj.io
|
|
spec:
|
|
destination:
|
|
namespace: sth
|
|
server: 'https://kubernetes.default.svc'
|
|
project: default
|
|
source:
|
|
repoURL: 'https://github.com/pasha-codefresh/argocd-example-apps'
|
|
targetRevision: HEAD
|
|
path: apps
|
|
helm:
|
|
valueFiles:
|
|
- values.yaml
|
|
---
|
|
# Source: apps/templates/helm.yaml
|
|
apiVersion: argoproj.io/v1alpha1
|
|
kind: Application
|
|
metadata:
|
|
name: sth2
|
|
namespace: argocd
|
|
finalizers:
|
|
- resources-finalizer.argocd.argoproj.io
|
|
spec:
|
|
destination:
|
|
namespace: sth
|
|
server: 'https://kubernetes.default.svc'
|
|
project: default
|
|
source:
|
|
repoURL: 'https://github.com/pasha-codefresh/argocd-example-apps'
|
|
targetRevision: HEAD
|
|
path: apps
|
|
helm:
|
|
valueFiles:
|
|
- values.yaml`
|
|
|
|
func TestReadAppsFromURI(t *testing.T) {
|
|
t.Parallel()
|
|
file, err := os.CreateTemp(os.TempDir(), "")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer func() {
|
|
_ = os.Remove(file.Name())
|
|
}()
|
|
|
|
_, _ = file.WriteString(appsYaml)
|
|
_ = file.Sync()
|
|
|
|
apps := make([]*v1alpha1.Application, 0)
|
|
err = readAppsFromURI(file.Name(), &apps)
|
|
require.NoError(t, err)
|
|
assert.Len(t, apps, 2)
|
|
|
|
assert.Equal(t, "sth1", apps[0].Name)
|
|
assert.Equal(t, "sth2", apps[1].Name)
|
|
}
|
|
|
|
func TestConstructAppFromStdin(t *testing.T) {
|
|
t.Parallel()
|
|
file, err := os.CreateTemp(os.TempDir(), "")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer func() {
|
|
_ = os.Remove(file.Name())
|
|
}()
|
|
|
|
_, _ = file.WriteString(appsYaml)
|
|
_ = file.Sync()
|
|
|
|
if _, err := file.Seek(0, 0); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
os.Stdin = file
|
|
|
|
apps, err := ConstructApps("-", "test", []string{}, []string{}, []string{}, AppOptions{}, nil)
|
|
|
|
if err := file.Close(); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
require.NoError(t, err)
|
|
assert.Len(t, apps, 2)
|
|
assert.Equal(t, "sth1", apps[0].Name)
|
|
assert.Equal(t, "sth2", apps[1].Name)
|
|
}
|
|
|
|
func TestConstructBasedOnName(t *testing.T) {
|
|
t.Parallel()
|
|
apps, err := ConstructApps("", "test", []string{}, []string{}, []string{}, AppOptions{}, nil)
|
|
|
|
require.NoError(t, err)
|
|
assert.Len(t, apps, 1)
|
|
assert.Equal(t, "test", apps[0].Name)
|
|
}
|
|
|
|
func TestFilterResources(t *testing.T) {
|
|
t.Parallel()
|
|
t.Run("Filter by ns", func(t *testing.T) {
|
|
t.Parallel()
|
|
resources := []*v1alpha1.ResourceDiff{
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm-guestbook\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm-guestbook\",\"namespace\":\"ns\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
}
|
|
|
|
filteredResources, err := FilterResources(false, resources, "g", "Service", "ns", "test-helm-guestbook", true)
|
|
require.NoError(t, err)
|
|
assert.Len(t, filteredResources, 1)
|
|
})
|
|
|
|
t.Run("Filter by kind", func(t *testing.T) {
|
|
t.Parallel()
|
|
resources := []*v1alpha1.ResourceDiff{
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm-guestbook\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Deployment\",\"metadata\":{\"name\":\"test-helm-guestbook\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
}
|
|
|
|
filteredResources, err := FilterResources(false, resources, "g", "Deployment", "argocd", "test-helm-guestbook", true)
|
|
require.NoError(t, err)
|
|
assert.Len(t, filteredResources, 1)
|
|
})
|
|
|
|
t.Run("Filter by name", func(t *testing.T) {
|
|
t.Parallel()
|
|
resources := []*v1alpha1.ResourceDiff{
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm-guestbook\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
}
|
|
|
|
filteredResources, err := FilterResources(false, resources, "g", "Service", "argocd", "test-helm", true)
|
|
require.NoError(t, err)
|
|
assert.Len(t, filteredResources, 1)
|
|
})
|
|
|
|
t.Run("Filter no result", func(t *testing.T) {
|
|
t.Parallel()
|
|
resources := []*v1alpha1.ResourceDiff{
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm-guestbook\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
}
|
|
|
|
filteredResources, err := FilterResources(false, resources, "g", "Service", "argocd-unknown", "test-helm", true)
|
|
require.ErrorContains(t, err, "no matching resource found")
|
|
assert.Nil(t, filteredResources)
|
|
})
|
|
|
|
t.Run("Filter multiple results", func(t *testing.T) {
|
|
t.Parallel()
|
|
resources := []*v1alpha1.ResourceDiff{
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
{
|
|
LiveState: "{\"apiVersion\":\"v1\",\"kind\":\"Service\",\"metadata\":{\"name\":\"test-helm\",\"namespace\":\"argocd\"},\"spec\":{\"selector\":{\"app\":\"helm-guestbook\",\"release\":\"test\"},\"sessionAffinity\":\"None\",\"type\":\"ClusterIP\"},\"status\":{\"loadBalancer\":{}}}",
|
|
},
|
|
}
|
|
|
|
filteredResources, err := FilterResources(false, resources, "g", "Service", "argocd", "test-helm", false)
|
|
require.ErrorContains(t, err, "use the --all flag")
|
|
assert.Nil(t, filteredResources)
|
|
})
|
|
}
|