540 lines
15 KiB
Go
540 lines
15 KiB
Go
package state
|
|
|
|
import (
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
|
|
"github.com/helmfile/helmfile/pkg/environment"
|
|
ffs "github.com/helmfile/helmfile/pkg/filesystem"
|
|
"github.com/helmfile/helmfile/pkg/helmexec"
|
|
"github.com/helmfile/helmfile/pkg/remote"
|
|
)
|
|
|
|
func newLoader() *EnvironmentValuesLoader {
|
|
log := helmexec.NewLogger(io.Discard, "debug")
|
|
|
|
storage := &Storage{
|
|
FilePath: "./helmfile.yaml",
|
|
basePath: ".",
|
|
fs: ffs.DefaultFileSystem(),
|
|
logger: log,
|
|
}
|
|
|
|
return NewEnvironmentValuesLoader(storage, storage.fs, log, remote.NewRemote(log, "/tmp", storage.fs))
|
|
}
|
|
|
|
// See https://github.com/roboll/helmfile/pull/1169
|
|
func TestEnvValsLoad_SingleValuesFile(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"testdata/values.5.yaml"}, nil, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"affinity": map[string]any{},
|
|
}
|
|
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
}
|
|
|
|
func TestEnvValsLoad_EnvironmentNameFile(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
expected := map[string]any{
|
|
"envName": "test",
|
|
}
|
|
emptyExpected := map[string]any{
|
|
"envName": nil,
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
env *environment.Environment
|
|
envName string
|
|
expected map[string]any
|
|
}{
|
|
{
|
|
name: "env is nil but envName is not",
|
|
env: nil,
|
|
envName: "test",
|
|
expected: expected,
|
|
},
|
|
{
|
|
name: "envName is emplte but env is not",
|
|
env: environment.New("test"),
|
|
envName: "",
|
|
expected: expected,
|
|
},
|
|
{
|
|
name: "envName and env is not nil",
|
|
env: environment.New("test"),
|
|
envName: "test",
|
|
expected: expected,
|
|
},
|
|
{
|
|
name: "envName and env is nil",
|
|
env: nil,
|
|
envName: "",
|
|
expected: emptyExpected,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"testdata/values.6.yaml.gotmpl"}, tt.env, tt.envName, "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if diff := cmp.Diff(tt.expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// Fetch Environment values from remote
|
|
func TestEnvValsLoad_SingleValuesFileRemote(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"git::https://github.com/helm/helm.git@cmd/helm/testdata/output/values.yaml?ref=v3.8.1"}, nil, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"name": string("value"),
|
|
}
|
|
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
}
|
|
|
|
// See https://github.com/roboll/helmfile/issues/1150
|
|
func TestEnvValsLoad_OverwriteNilValue_Issue1150(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"testdata/values.1.yaml", "testdata/values.2.yaml"}, nil, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"components": map[string]any{
|
|
"etcd-operator": map[string]any{
|
|
"version": "0.10.3",
|
|
},
|
|
},
|
|
}
|
|
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
}
|
|
|
|
// See https://github.com/roboll/helmfile/issues/1154
|
|
func TestEnvValsLoad_OverwriteWithNilValue_Issue1154(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"testdata/values.3.yaml", "testdata/values.4.yaml"}, nil, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"components": map[string]any{
|
|
"etcd-operator": map[string]any{
|
|
"version": "0.10.3",
|
|
},
|
|
"prometheus": nil,
|
|
},
|
|
}
|
|
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
}
|
|
|
|
// See https://github.com/roboll/helmfile/issues/1168
|
|
func TestEnvValsLoad_OverwriteEmptyValue_Issue1168(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"testdata/issues/1168/addons.yaml", "testdata/issues/1168/addons2.yaml"}, nil, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"addons": map[string]any{
|
|
"mychart": map[string]any{
|
|
"skip": false,
|
|
"name": "mychart",
|
|
"namespace": "kube-system",
|
|
"chart": "stable/mychart",
|
|
"version": "1.0.0",
|
|
},
|
|
},
|
|
}
|
|
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
}
|
|
|
|
func TestEnvValsLoad_MultiHCL(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"testdata/values.7.hcl", "testdata/values.8.hcl"}, nil, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"a": "a",
|
|
"b": "b",
|
|
"c": "ab",
|
|
"map": map[string]any{
|
|
"a": "a",
|
|
},
|
|
"list": []any{
|
|
"b",
|
|
},
|
|
"nestedmap": map[string]any{
|
|
"submap": map[string]any{
|
|
"subsubmap": map[string]any{
|
|
"hello": "ab",
|
|
},
|
|
},
|
|
},
|
|
"ternary": true,
|
|
"fromMap": "aab",
|
|
"expressionInText": "yes",
|
|
"insideFor": "b",
|
|
"multi_block": "block",
|
|
"block": "block",
|
|
"crossfile": "crossfile var",
|
|
"crossfile_var": "crossfile var",
|
|
"localRef": "localInValues7",
|
|
}
|
|
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
}
|
|
|
|
func TestEnvValsLoad_EnvironmentValues(t *testing.T) {
|
|
l := newLoader()
|
|
env := environment.New("test")
|
|
env.Values["foo"] = "bar"
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil, []any{"testdata/values.9.yaml.gotmpl"}, env, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"foo": "bar",
|
|
}
|
|
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Error(diff)
|
|
}
|
|
}
|
|
|
|
// --- mergeStrategy: fallback ---
|
|
|
|
// Earlier files take precedence. Same conflicting key in two files →
|
|
// the value from default.yaml (loaded first) wins.
|
|
func TestEnvValsLoad_FallbackStrategy_EarlierWins(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cluster := actual["cluster"].(map[string]any)
|
|
if got := cluster["domain"]; got != "example.com" {
|
|
t.Errorf("cluster.domain: want %q (from default.yaml), got %v", "example.com", got)
|
|
}
|
|
}
|
|
|
|
// Later files only fill keys that are missing from earlier files.
|
|
func TestEnvValsLoad_FallbackStrategy_FillsGaps(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cluster := actual["cluster"].(map[string]any)
|
|
if got := cluster["region"]; got != "us-east-1" {
|
|
t.Errorf("cluster.region: want %q (from fallback.yaml, missing in default.yaml), got %v", "us-east-1", got)
|
|
}
|
|
service := actual["service"].(map[string]any)
|
|
if got := service["port"]; got != 8080 {
|
|
t.Errorf("service.port: want 8080 (from fallback.yaml), got %v", got)
|
|
}
|
|
}
|
|
|
|
// Nested maps merge recursively: top-level cluster is not replaced
|
|
// wholesale; both files contribute keys.
|
|
func TestEnvValsLoad_FallbackStrategy_DeepMerge(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"cluster": map[string]any{
|
|
"domain": "example.com", // from default (wins)
|
|
"region": "us-east-1", // from fallback (gap filled)
|
|
},
|
|
"service": map[string]any{
|
|
"port": 8080, // from fallback (gap filled)
|
|
},
|
|
}
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Errorf("deep merge mismatch (-want +got):\n%s", diff)
|
|
}
|
|
}
|
|
|
|
// First-wins precedence holds across an arbitrarily long chain, not just
|
|
// pairwise. Three files exercise the accumulator state across iterations.
|
|
func TestEnvValsLoad_FallbackStrategy_ChainedFiles(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{
|
|
"testdata/mergestrategy/chain_a.yaml",
|
|
"testdata/mergestrategy/chain_b.yaml",
|
|
"testdata/mergestrategy/chain_c.yaml",
|
|
},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"letter": "a", // only in a
|
|
"only_a": "from-a", // only in a
|
|
"only_b": "from-b", // only in b
|
|
"only_c": "from-c", // only in c
|
|
"both_ab": "from-a", // a and b → a wins (earlier)
|
|
"both_bc": "from-b", // b and c → b wins (earlier)
|
|
"all_three": "from-a", // a, b, c → a wins (earliest)
|
|
}
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Errorf("chain mismatch (-want +got):\n%s", diff)
|
|
}
|
|
}
|
|
|
|
// Explicit zero values in the earlier file MUST be preserved. Without the
|
|
// hand-rolled fallbackDeepMerge, mergo's isEmptyValue would silently let
|
|
// `enabled: true` from fallback overwrite `enabled: false` from default.
|
|
func TestEnvValsLoad_FallbackStrategy_PreservesExplicitZeroValues(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/zero_default.yaml", "testdata/mergestrategy/zero_fallback.yaml"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{
|
|
"enabled": false,
|
|
"replicas": 0,
|
|
"name": "",
|
|
"tags": []any{},
|
|
}
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Errorf("explicit zero values not preserved (-want +got):\n%s", diff)
|
|
}
|
|
}
|
|
|
|
// Explicit nil in the earlier file does NOT win under fallback: it falls
|
|
// through to the fallback file's value. This matches helmfile's existing
|
|
// MergeMaps treatment of nil ("nil from the override side only fills missing
|
|
// keys"; here, by argument-swap, nil from the winner is treated as
|
|
// "no preference, let the fallback fill it"). Documented as the deliberate
|
|
// difference from override mode, where mergo.WithOverride lets nil overwrite
|
|
// (see TestEnvValsLoad_OverwriteWithNilValue_Issue1154).
|
|
func TestEnvValsLoad_FallbackStrategy_NilFallsThroughToFallback(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/nil_default.yaml", "testdata/mergestrategy/nil_fallback.yaml"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expected := map[string]any{"value": "from-fallback"}
|
|
if diff := cmp.Diff(expected, actual); diff != "" {
|
|
t.Errorf("explicit nil should fall through to fallback (-want +got):\n%s", diff)
|
|
}
|
|
}
|
|
|
|
// Inline map entries (not file paths) also honor the fallback strategy.
|
|
func TestEnvValsLoad_FallbackStrategy_InlineMapEntry(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
inline := map[string]any{
|
|
"cluster": map[string]any{"domain": "inline.example"},
|
|
"extra": "from-inline",
|
|
}
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{inline, "testdata/mergestrategy/fallback.yaml"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cluster := actual["cluster"].(map[string]any)
|
|
if got := cluster["domain"]; got != "inline.example" {
|
|
t.Errorf("cluster.domain: want inline value to win, got %v", got)
|
|
}
|
|
if got := actual["extra"]; got != "from-inline" {
|
|
t.Errorf("extra: want %q, got %v", "from-inline", got)
|
|
}
|
|
// fallback.yaml still fills gaps the inline map did not set.
|
|
if got := cluster["region"]; got != "us-east-1" {
|
|
t.Errorf("cluster.region: want %q from fallback file, got %v", "us-east-1", got)
|
|
}
|
|
}
|
|
|
|
// Regression guard: explicit "override" matches today's behavior
|
|
// (last file wins).
|
|
func TestEnvValsLoad_OverrideStrategy_PreservesCurrentBehavior(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml"},
|
|
nil, "", MergeStrategyOverride)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cluster := actual["cluster"].(map[string]any)
|
|
if got := cluster["domain"]; got != "cluster.local" {
|
|
t.Errorf("cluster.domain under override: want %q (from fallback.yaml), got %v", "cluster.local", got)
|
|
}
|
|
}
|
|
|
|
// Empty strategy is identical to explicit "override".
|
|
func TestEnvValsLoad_DefaultStrategy_MatchesOverride(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
asDefault, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml"},
|
|
nil, "", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
asOverride, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml"},
|
|
nil, "", MergeStrategyOverride)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if diff := cmp.Diff(asOverride, asDefault); diff != "" {
|
|
t.Errorf("default strategy diverges from override (-override +default):\n%s", diff)
|
|
}
|
|
}
|
|
|
|
// Within a single `values:` entry that expands to multiple files (a glob), a
|
|
// later .gotmpl in the expansion can reference earlier files in that same
|
|
// expansion. Matters because the inner file loop must merge each parsed file
|
|
// into the accumulator before rendering the next, not buffer the whole
|
|
// expansion and merge once at the end.
|
|
func TestEnvValsLoad_FallbackStrategy_GlobTemplateSeesPriorFileInSameExpansion(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/glob_*.yaml*"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
service := actual["service"].(map[string]any)
|
|
if got := service["domain"]; got != "service.example.com" {
|
|
t.Errorf("service.domain: want %q (templated from sibling glob match), got %v",
|
|
"service.example.com", got)
|
|
}
|
|
}
|
|
|
|
// The headline use case: under fallback, a later .gotmpl values file can
|
|
// reference values defined by earlier files in the same list via .Values.
|
|
// default.yaml sets cluster.domain; fallback.yaml.gotmpl renders
|
|
// `service.domain: "service.{{ .Values.cluster.domain }}"`.
|
|
func TestEnvValsLoad_FallbackStrategy_TemplateAccessesPriorFile(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
actual, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml.gotmpl"},
|
|
nil, "", MergeStrategyFallback)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
service := actual["service"].(map[string]any)
|
|
if got := service["domain"]; got != "service.example.com" {
|
|
t.Errorf("service.domain: want %q (templated from prior file), got %v",
|
|
"service.example.com", got)
|
|
}
|
|
}
|
|
|
|
// Symmetric guard: under override, the same .gotmpl reference does NOT
|
|
// see prior files in the same list. Documents the deliberate scoping:
|
|
// the cross-file template enrichment is opt-in via mergeStrategy: fallback.
|
|
func TestEnvValsLoad_OverrideStrategy_TemplateContextUnchanged(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
_, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml", "testdata/mergestrategy/fallback.yaml.gotmpl"},
|
|
nil, "", MergeStrategyOverride)
|
|
if err == nil {
|
|
t.Fatal("expected template render error: under override, .Values.cluster.domain should not resolve to a prior file's value")
|
|
}
|
|
// The exact error wording is owned by the template renderer; we only
|
|
// assert that we got an error rather than a bogus successful render.
|
|
}
|
|
|
|
// Unknown strategy values produce a clear error that names both the bad
|
|
// value and the valid options.
|
|
func TestEnvValsLoad_InvalidStrategy_Errors(t *testing.T) {
|
|
l := newLoader()
|
|
|
|
_, err := l.LoadEnvironmentValues(nil,
|
|
[]any{"testdata/mergestrategy/default.yaml"},
|
|
nil, "prod", "bogus")
|
|
if err == nil {
|
|
t.Fatal("expected error for invalid mergeStrategy, got nil")
|
|
}
|
|
for _, want := range []string{"prod", "bogus", MergeStrategyOverride, MergeStrategyFallback} {
|
|
if !strings.Contains(err.Error(), want) {
|
|
t.Errorf("error message missing %q: %v", want, err)
|
|
}
|
|
}
|
|
}
|