package config import ( "strings" "testing" "time" ) // Cover the annotation parser used by cozystack-api at startup. The parser // is consumed by pkg/cmd/server/start.go on every ApplicationDefinition; a // typo here silently drops back to flux defaults and the Kubernetes tenant // race described in cozystack#2412 reappears, so the table must exercise: // - the unset path (empty string treated as "no override"), // - every unit Flux accepts (ms, s, m, h), // - compound forms (the CRD pattern accepts repeats), // - units time.ParseDuration accepts but Flux rejects (ns, us, µs), // - outright garbage. func TestParseHelmTimeoutAnnotation(t *testing.T) { cases := []struct { name string input string want time.Duration wantErr bool errMatch string }{ { name: "empty string leaves flux defaults in place", input: "", want: 0, }, { name: "minutes", input: "15m", want: 15 * time.Minute, }, { name: "hours", input: "1h", want: time.Hour, }, { name: "seconds", input: "45s", want: 45 * time.Second, }, { name: "milliseconds", input: "500ms", want: 500 * time.Millisecond, }, { name: "compound hour and minutes", input: "2h30m", want: 2*time.Hour + 30*time.Minute, }, { name: "decimal minutes", input: "1.5m", want: 90 * time.Second, }, { name: "nanoseconds rejected - Flux CRD pattern excludes ns", input: "500ns", wantErr: true, errMatch: "Flux accepts ms/s/m/h units only", }, { name: "microseconds rejected - Flux CRD pattern excludes us", input: "500us", wantErr: true, errMatch: "Flux accepts ms/s/m/h units only", }, { name: "microseconds unicode rejected", input: "500µs", wantErr: true, errMatch: "Flux accepts ms/s/m/h units only", }, { name: "bare digits rejected", input: "15", wantErr: true, errMatch: "Flux accepts ms/s/m/h units only", }, { name: "garbage rejected", input: "abc", wantErr: true, errMatch: "Flux accepts ms/s/m/h units only", }, { name: "negative rejected", input: "-15m", wantErr: true, errMatch: "Flux accepts ms/s/m/h units only", }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { got, err := ParseHelmTimeoutAnnotation(tc.input) if tc.wantErr { if err == nil { t.Fatalf("expected error, got duration=%v", got) } if tc.errMatch != "" && !strings.Contains(err.Error(), tc.errMatch) { t.Errorf("error %q does not contain %q", err.Error(), tc.errMatch) } return } if err != nil { t.Fatalf("unexpected error: %v", err) } if got != tc.want { t.Errorf("got %v, want %v", got, tc.want) } }) } } // ParsePositiveDuration is the startup validator shared by cozystack-operator // and cozystack-api. Both binaries reject zero/negative/malformed values so a // misconfigured flag fails fast instead of propagating into every generated // HelmRelease and being rejected by helm-controller's CRD validation later. func TestParsePositiveDuration(t *testing.T) { tests := []struct { name string raw string want time.Duration // errMatch pins which of the two error branches fired: a // time.ParseDuration failure ("invalid duration") versus a // non-positive value ("must be > 0"). Keeps the two diagnostics // from drifting and operators seeing the wrong message. errMatch string wantErr bool }{ {name: "valid seconds", raw: "30s", want: 30 * time.Second}, {name: "valid minutes", raw: "5m", want: 5 * time.Minute}, {name: "valid compound", raw: "1h30m", want: 90 * time.Minute}, {name: "zero rejected", raw: "0s", wantErr: true, errMatch: "must be > 0"}, {name: "negative rejected", raw: "-5m", wantErr: true, errMatch: "must be > 0"}, {name: "malformed rejected", raw: "5x", wantErr: true, errMatch: "invalid duration"}, {name: "empty rejected", raw: "", wantErr: true, errMatch: "invalid duration"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := ParsePositiveDuration("--test-flag", tt.raw) if tt.wantErr { if err == nil { t.Fatalf("expected error for %q, got nil", tt.raw) } if tt.errMatch != "" && !strings.Contains(err.Error(), tt.errMatch) { t.Errorf("error %q does not contain %q", err.Error(), tt.errMatch) } return } if err != nil { t.Fatalf("unexpected error for %q: %v", tt.raw, err) } if got != tt.want { t.Errorf("got %v, want %v", got, tt.want) } }) } } // Cover the disable-wait annotation parser. cozystack-api consumes it on // every ApplicationDefinition at startup (see pkg/cmd/server/start.go); // a typo in the parsed value silently drops back to false and the // chicken-and-egg deadlock between the kubernetes chart and its emitted // in-tenant addon HelmReleases reappears (parent chart waits for child // HRs Ready before running post-install hooks, child HRs cannot be Ready // without the TalosConfigTemplate the parent's hook produces, deadlock). // Mirrors the sibling timeout parser table. func TestParseHelmInstallDisableWaitAnnotation(t *testing.T) { cases := []struct { name string input string want bool wantErr bool errMatch string }{ { name: "empty string leaves flux defaults in place", input: "", want: false, }, { name: "lower-case true", input: "true", want: true, }, { name: "title-case True", input: "True", want: true, }, { name: "upper-case TRUE", input: "TRUE", want: true, }, { name: "lower-case false", input: "false", want: false, }, { name: "title-case False", input: "False", want: false, }, { name: "upper-case FALSE", input: "FALSE", want: false, }, { name: "mixed-case true accepted (case-insensitive)", input: "tRue", want: true, }, { name: "mixed-case false accepted (case-insensitive)", input: "fAlSe", want: false, }, { name: "surrounding whitespace trimmed", input: " true ", want: true, }, { name: "integer rejected", input: "1", wantErr: true, errMatch: `must be "true" or "false"`, }, { name: "yes/no idiom rejected", input: "yes", wantErr: true, errMatch: `must be "true" or "false"`, }, { name: "garbage rejected", input: "abc", wantErr: true, errMatch: `must be "true" or "false"`, }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { got, err := ParseHelmInstallDisableWaitAnnotation(tc.input) if tc.wantErr { if err == nil { t.Fatalf("expected error, got %v", got) } if tc.errMatch != "" && !strings.Contains(err.Error(), tc.errMatch) { t.Errorf("error %q does not contain %q", err.Error(), tc.errMatch) } return } if err != nil { t.Fatalf("unexpected error: %v", err) } if got != tc.want { t.Errorf("got %v, want %v", got, tc.want) } }) } } func TestParseHelmServerSideApplyAnnotation(t *testing.T) { tru := true fls := false cases := []struct { name string input string want *bool wantErr bool errMatch string }{ {name: "empty leaves helm-controller default", input: "", want: nil}, {name: "false forces client-side", input: "false", want: &fls}, {name: "disabled forces client-side", input: "disabled", want: &fls}, {name: "true forces server-side", input: "true", want: &tru}, {name: "enabled forces server-side", input: "enabled", want: &tru}, {name: "mixed-case accepted", input: " Disabled ", want: &fls}, {name: "auto rejected (only true/false accepted here)", input: "auto", wantErr: true, errMatch: `must be`}, {name: "garbage rejected", input: "abc", wantErr: true, errMatch: `must be`}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { got, err := ParseHelmServerSideApplyAnnotation(tc.input) if tc.wantErr { if err == nil { t.Fatalf("expected error, got %v", got) } if tc.errMatch != "" && !strings.Contains(err.Error(), tc.errMatch) { t.Errorf("error %q does not contain %q", err.Error(), tc.errMatch) } return } if err != nil { t.Fatalf("unexpected error: %v", err) } switch { case tc.want == nil && got != nil: t.Errorf("got %v, want nil", *got) case tc.want != nil && got == nil: t.Errorf("got nil, want %v", *tc.want) case tc.want != nil && got != nil && *got != *tc.want: t.Errorf("got %v, want %v", *got, *tc.want) } }) } } // TestReleaseAnnotationsShareThePrefix pins that every annotation cozystack-api // reads off an ApplicationDefinition lives under ReleaseAnnotationPrefix. // cozystack-operator selects them by that prefix when it hashes the definitions // to decide whether to roll the api Deployment, so an annotation introduced // outside the prefix would be read at start-up but never trigger the restart // that delivers it. func TestReleaseAnnotationsShareThePrefix(t *testing.T) { for _, annotation := range []string{ HelmInstallTimeoutAnnotation, HelmUpgradeTimeoutAnnotation, HelmInstallDisableWaitAnnotation, HelmServerSideApplyAnnotation, } { if !strings.HasPrefix(annotation, ReleaseAnnotationPrefix) { t.Errorf("annotation %q is outside %q, so a change to it never rolls cozystack-api", annotation, ReleaseAnnotationPrefix) } } }