620 lines
16 KiB
Go
620 lines
16 KiB
Go
package maputil
|
|
|
|
import (
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestMapUtil_StrKeys(t *testing.T) {
|
|
m := map[string]any{
|
|
"a": []any{
|
|
map[string]any{
|
|
"b": []any{
|
|
map[string]any{
|
|
"c": "C",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
r, err := CastKeysToStrings(m)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
a := r["a"].([]any)
|
|
a0 := a[0].(map[string]any)
|
|
b := a0["b"].([]any)
|
|
b0 := b[0].(map[string]any)
|
|
c := b0["c"]
|
|
|
|
if c != "C" {
|
|
t.Errorf("unexpected c: expected=C, got=%s", c)
|
|
}
|
|
}
|
|
|
|
func TestMapUtil_IFKeys(t *testing.T) {
|
|
m := map[any]any{
|
|
"a": []any{
|
|
map[any]any{
|
|
"b": []any{
|
|
map[any]any{
|
|
"c": "C",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
r, err := CastKeysToStrings(m)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
a := r["a"].([]any)
|
|
a0 := a[0].(map[string]any)
|
|
b := a0["b"].([]any)
|
|
b0 := b[0].(map[string]any)
|
|
c := b0["c"]
|
|
|
|
if c != "C" {
|
|
t.Errorf("unexpected c: expected=C, got=%s", c)
|
|
}
|
|
}
|
|
|
|
func TestMapUtil_KeyArg(t *testing.T) {
|
|
m := map[string]any{}
|
|
|
|
key := []string{"a", "b", "c"}
|
|
|
|
Set(m, key, "C", false)
|
|
|
|
c := (((m["a"].(map[string]any))["b"]).(map[string]any))["c"]
|
|
|
|
if c != "C" {
|
|
t.Errorf("unexpected c: expected=C, got=%s", c)
|
|
}
|
|
}
|
|
|
|
func TestMapUtil_IndexedKeyArg(t *testing.T) {
|
|
m := map[string]any{}
|
|
|
|
key := []string{"a", "b[0]", "c"}
|
|
|
|
Set(m, key, "C", false)
|
|
|
|
c := (((m["a"].(map[string]any))["b"].([]any))[0].(map[string]any))["c"]
|
|
|
|
if c != "C" {
|
|
t.Errorf("unexpected c: expected=C, got=%s", c)
|
|
}
|
|
}
|
|
|
|
func TestMapUtil_IndexedKeyArg2(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
stateValuesSet []string
|
|
want map[string]any
|
|
}{
|
|
{
|
|
name: "IndexedKeyArg",
|
|
stateValuesSet: []string{"myvalues[0]=HELLO,myvalues[1]=HELMFILE"},
|
|
want: map[string]any{"myvalues": []any{"HELLO", "HELMFILE"}},
|
|
},
|
|
{
|
|
name: "two state value",
|
|
stateValuesSet: []string{"myvalues[0]=HELLO,myvalues[1]=HELMFILE", "myvalues[2]=HELLO"},
|
|
want: map[string]any{"myvalues": []any{"HELLO", "HELMFILE", "HELLO"}},
|
|
},
|
|
{
|
|
name: "different key",
|
|
stateValuesSet: []string{"myvalues[0]=HELLO,key2[0]=HELMFILE", "myvalues[1]=HELLO2"},
|
|
want: map[string]any{"myvalues": []any{"HELLO", "HELLO2"}, "key2": []any{"HELMFILE"}},
|
|
},
|
|
}
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
set := map[string]any{}
|
|
for i := range c.stateValuesSet {
|
|
ops := strings.Split(c.stateValuesSet[i], ",")
|
|
for j := range ops {
|
|
op := strings.SplitN(ops[j], "=", 2)
|
|
k := ParseKey(op[0])
|
|
v := op[1]
|
|
|
|
Set(set, k, v, false)
|
|
}
|
|
}
|
|
if !reflect.DeepEqual(set, c.want) {
|
|
t.Errorf("expected set %v, got %v", c.want, set)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type parseKeyTc struct {
|
|
key string
|
|
result map[int]string
|
|
}
|
|
|
|
func TestMapUtil_ParseKey(t *testing.T) {
|
|
tcs := []parseKeyTc{
|
|
{
|
|
key: `a.b.c`,
|
|
result: map[int]string{
|
|
0: "a",
|
|
1: "b",
|
|
2: "c",
|
|
},
|
|
},
|
|
{
|
|
key: `a\.b.c`,
|
|
result: map[int]string{
|
|
0: "a.b",
|
|
1: "c",
|
|
},
|
|
},
|
|
{
|
|
key: `a\.b\.c`,
|
|
result: map[int]string{
|
|
0: "a.b.c",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tcs {
|
|
parts := ParseKey(tc.key)
|
|
|
|
for index, value := range tc.result {
|
|
if parts[index] != value {
|
|
t.Errorf("unexpected key part[%d]: expected=%s, got=%s", index, value, parts[index])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMapUtil_typedVal(t *testing.T) {
|
|
typedValueTest(t, "true", true)
|
|
typedValueTest(t, "null", nil)
|
|
typedValueTest(t, "0", int64(0))
|
|
typedValueTest(t, "5", int64(5))
|
|
typedValueTest(t, "05", "05")
|
|
}
|
|
|
|
func typedValueTest(t *testing.T, input string, expectedWhenNoStr any) {
|
|
returnValue := typedVal(input, true)
|
|
if returnValue != input {
|
|
t.Errorf("unexpected typed value: expected=%s, got=%s", input, returnValue)
|
|
}
|
|
returnValue = typedVal(input, false)
|
|
if returnValue != expectedWhenNoStr {
|
|
t.Errorf("unexpected typed value: expected=%s, got=%s", input, returnValue)
|
|
}
|
|
}
|
|
|
|
func TestMapUtil_MergeMaps(t *testing.T) {
|
|
map1 := map[string]interface{}{
|
|
"debug": true,
|
|
}
|
|
map2 := map[string]interface{}{
|
|
"logLevel": "info",
|
|
"replicaCount": 3,
|
|
}
|
|
map3 := map[string]interface{}{
|
|
"logLevel": "info",
|
|
"replicaCount": map[string]any{
|
|
"app1": 3,
|
|
"awesome": 4,
|
|
},
|
|
}
|
|
map4 := map[string]interface{}{
|
|
"logLevel": "info",
|
|
"replicaCount": map[string]any{
|
|
"app1": 3,
|
|
},
|
|
}
|
|
map5 := map[string]interface{}{
|
|
"logLevel": "error",
|
|
"replicaCount": nil,
|
|
}
|
|
|
|
testMap := MergeMaps(map2, map4)
|
|
equal := reflect.DeepEqual(testMap, map4)
|
|
if !equal {
|
|
t.Errorf("Expected a nested map to overwrite a flat value. Expected: %v, got %v", map4, testMap)
|
|
}
|
|
|
|
testMap = MergeMaps(map4, map2)
|
|
equal = reflect.DeepEqual(testMap, map2)
|
|
if !equal {
|
|
t.Errorf("Expected a flat value to overwrite a map. Expected: %v, got %v", map2, testMap)
|
|
}
|
|
|
|
testMap = MergeMaps(map4, map3)
|
|
equal = reflect.DeepEqual(testMap, map3)
|
|
if !equal {
|
|
t.Errorf("Expected a nested map to overwrite another nested map. Expected: %v, got %v", map3, testMap)
|
|
}
|
|
|
|
testMap = MergeMaps(map1, map3)
|
|
expectedMap := map[string]interface{}{
|
|
"debug": true,
|
|
"logLevel": "info",
|
|
"replicaCount": map[string]any{
|
|
"app1": 3,
|
|
"awesome": 4,
|
|
},
|
|
}
|
|
equal = reflect.DeepEqual(testMap, expectedMap)
|
|
if !equal {
|
|
t.Errorf("Expected a map with different keys to merge properly with another map. Expected: %v, got %v", expectedMap, testMap)
|
|
}
|
|
|
|
testMap = MergeMaps(map3, map5)
|
|
expectedMap = map[string]interface{}{
|
|
"logLevel": "error",
|
|
"replicaCount": map[string]any{
|
|
"app1": 3,
|
|
"awesome": 4,
|
|
},
|
|
}
|
|
equal = reflect.DeepEqual(testMap, expectedMap)
|
|
if !equal {
|
|
t.Errorf("Expected a map with empty value not to overwrite another map's value. Expected: %v, got %v", expectedMap, testMap)
|
|
}
|
|
}
|
|
|
|
// TestMapUtil_Issue2281_ArrayMerging tests the bug reported in issue #2281
|
|
// where setting nested values in arrays replaces the entire object
|
|
func TestMapUtil_Issue2281_ArrayMerging(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
initialMap map[string]any
|
|
operations []struct {
|
|
key []string
|
|
value string
|
|
}
|
|
expected map[string]any
|
|
}{
|
|
{
|
|
name: "simple array element replacement should preserve other elements",
|
|
initialMap: map[string]any{
|
|
"top": map[string]any{
|
|
"array": []any{"thing1", "thing2"},
|
|
},
|
|
},
|
|
operations: []struct {
|
|
key []string
|
|
value string
|
|
}{
|
|
{key: []string{"top", "array[0]"}, value: "cmdlinething1"},
|
|
},
|
|
expected: map[string]any{
|
|
"top": map[string]any{
|
|
"array": []any{"cmdlinething1", "thing2"},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "nested field in array object should merge not replace",
|
|
initialMap: map[string]any{
|
|
"top": map[string]any{
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "another thing",
|
|
},
|
|
map[string]any{
|
|
"thing": "second thing",
|
|
"anotherThing": "a second other thing",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
operations: []struct {
|
|
key []string
|
|
value string
|
|
}{
|
|
{key: []string{"top", "complexArray[1]", "anotherThing"}, value: "cmdline"},
|
|
},
|
|
expected: map[string]any{
|
|
"top": map[string]any{
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "another thing",
|
|
},
|
|
map[string]any{
|
|
"thing": "second thing",
|
|
"anotherThing": "cmdline",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "complete issue #2281 scenario",
|
|
initialMap: map[string]any{
|
|
"top": map[string]any{
|
|
"array": []any{"thing1", "thing2"},
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "another thing",
|
|
},
|
|
map[string]any{
|
|
"thing": "second thing",
|
|
"anotherThing": "a second other thing",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
operations: []struct {
|
|
key []string
|
|
value string
|
|
}{
|
|
{key: []string{"top", "array[0]"}, value: "cmdlinething1"},
|
|
{key: []string{"top", "complexArray[1]", "anotherThing"}, value: "cmdline"},
|
|
},
|
|
expected: map[string]any{
|
|
"top": map[string]any{
|
|
"array": []any{"cmdlinething1", "thing2"},
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "another thing",
|
|
},
|
|
map[string]any{
|
|
"thing": "second thing",
|
|
"anotherThing": "cmdline",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "setting nested value in first array element should preserve fields",
|
|
initialMap: map[string]any{
|
|
"top": map[string]any{
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "another thing",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
operations: []struct {
|
|
key []string
|
|
value string
|
|
}{
|
|
{key: []string{"top", "complexArray[0]", "anotherThing"}, value: "modified"},
|
|
},
|
|
expected: map[string]any{
|
|
"top": map[string]any{
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "modified",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := tt.initialMap
|
|
for _, op := range tt.operations {
|
|
Set(result, op.key, op.value, false)
|
|
}
|
|
|
|
if !reflect.DeepEqual(result, tt.expected) {
|
|
t.Errorf("Result mismatch:\nExpected: %+v\nGot: %+v", tt.expected, result)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestMapUtil_Issue2281_EmptyMapScenario demonstrates the actual bug
|
|
// when starting from an empty map (like --state-values-set does)
|
|
func TestMapUtil_Issue2281_EmptyMapScenario(t *testing.T) {
|
|
// This test demonstrates what currently happens vs what should happen
|
|
// when using --state-values-set with array indices
|
|
|
|
// What currently happens: setting multiple values creates sparse arrays with nulls
|
|
t.Run("current buggy behavior - demonstrates the issue", func(t *testing.T) {
|
|
set := map[string]any{}
|
|
|
|
// Simulating: --state-values-set top.array[0]=cmdlinething1
|
|
Set(set, []string{"top", "array[0]"}, "cmdlinething1", false)
|
|
|
|
// Check what we got
|
|
topArray := set["top"].(map[string]any)["array"].([]any)
|
|
|
|
// Currently this creates: ["cmdlinething1"]
|
|
// which is actually correct for a single set operation
|
|
if len(topArray) != 1 {
|
|
t.Errorf("Expected array length 1, got %d", len(topArray))
|
|
}
|
|
if topArray[0] != "cmdlinething1" {
|
|
t.Errorf("Expected array[0] to be 'cmdlinething1', got %v", topArray[0])
|
|
}
|
|
})
|
|
|
|
t.Run("actual bug - setting array index 1 without index 0 creates null at 0", func(t *testing.T) {
|
|
set := map[string]any{}
|
|
|
|
// Simulating: --state-values-set top.complexArray[1].anotherThing=cmdline
|
|
// WITHOUT first defining complexArray[0]
|
|
Set(set, []string{"top", "complexArray[1]", "anotherThing"}, "cmdline", false)
|
|
|
|
// Check what we got
|
|
topComplexArray := set["top"].(map[string]any)["complexArray"].([]any)
|
|
|
|
// BUG: This creates [nil, {anotherThing: "cmdline"}]
|
|
// The issue description says array entries not referenced are being deleted or set to null
|
|
if len(topComplexArray) != 2 {
|
|
t.Errorf("Expected array length 2, got %d", len(topComplexArray))
|
|
}
|
|
|
|
// Index 0 should be nil (this is the bug!)
|
|
if topComplexArray[0] != nil {
|
|
t.Logf("Note: topComplexArray[0] = %v (expected nil for this test showing the bug)", topComplexArray[0])
|
|
}
|
|
|
|
// Index 1 should have the value
|
|
obj1 := topComplexArray[1].(map[string]any)
|
|
if obj1["anotherThing"] != "cmdline" {
|
|
t.Errorf("Expected complexArray[1].anotherThing to be 'cmdline', got %v", obj1["anotherThing"])
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestMapUtil_Issue2281_MergeArrays tests that MergeMaps should merge arrays element-by-element
|
|
func TestMapUtil_Issue2281_MergeArrays(t *testing.T) {
|
|
t.Run("merging arrays should preserve elements from base that aren't in override", func(t *testing.T) {
|
|
// Base values from helmfile
|
|
base := map[string]interface{}{
|
|
"top": map[string]any{
|
|
"array": []any{"thing1", "thing2"},
|
|
},
|
|
}
|
|
|
|
// Override values from --state-values-set top.array[0]=cmdlinething1
|
|
override := map[string]interface{}{
|
|
"top": map[string]any{
|
|
"array": []any{"cmdlinething1"},
|
|
},
|
|
}
|
|
|
|
result := MergeMaps(base, override)
|
|
|
|
// Expected: array should be ["cmdlinething1", "thing2"]
|
|
// array[0] is overridden, array[1] is preserved from base
|
|
resultArray := result["top"].(map[string]any)["array"].([]any)
|
|
|
|
expected := []any{"cmdlinething1", "thing2"}
|
|
if !reflect.DeepEqual(resultArray, expected) {
|
|
t.Errorf("Array merge failed:\nExpected: %+v\nGot: %+v", expected, resultArray)
|
|
}
|
|
})
|
|
|
|
t.Run("merging complex arrays should preserve non-overridden elements and fields", func(t *testing.T) {
|
|
// Base values from helmfile
|
|
base := map[string]interface{}{
|
|
"top": map[string]any{
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "another thing",
|
|
},
|
|
map[string]any{
|
|
"thing": "second thing",
|
|
"anotherThing": "a second other thing",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
// Override values from --state-values-set top.complexArray[1].anotherThing=cmdline
|
|
override := map[string]interface{}{
|
|
"top": map[string]any{
|
|
"complexArray": []any{
|
|
nil,
|
|
map[string]any{
|
|
"anotherThing": "cmdline",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
result := MergeMaps(base, override)
|
|
|
|
// Expected: complexArray[0] should be unchanged, complexArray[1] should have merged fields
|
|
resultArray := result["top"].(map[string]any)["complexArray"].([]any)
|
|
|
|
// Check array length
|
|
if len(resultArray) != 2 {
|
|
t.Fatalf("Expected array length 2, got %d", len(resultArray))
|
|
}
|
|
|
|
// Check complexArray[0] is unchanged
|
|
elem0 := resultArray[0].(map[string]any)
|
|
if elem0["thing"] != "a thing" || elem0["anotherThing"] != "another thing" {
|
|
t.Errorf("complexArray[0] was modified:\nGot: %+v", elem0)
|
|
}
|
|
|
|
// Check complexArray[1] has merged fields
|
|
elem1 := resultArray[1].(map[string]any)
|
|
if elem1["thing"] != "second thing" {
|
|
t.Errorf("complexArray[1].thing should be preserved, got %v", elem1["thing"])
|
|
}
|
|
if elem1["anotherThing"] != "cmdline" {
|
|
t.Errorf("complexArray[1].anotherThing should be 'cmdline', got %v", elem1["anotherThing"])
|
|
}
|
|
})
|
|
|
|
t.Run("complete issue #2281 scenario with MergeMaps", func(t *testing.T) {
|
|
// Base values from helmfile
|
|
base := map[string]interface{}{
|
|
"top": map[string]any{
|
|
"array": []any{"thing1", "thing2"},
|
|
"complexArray": []any{
|
|
map[string]any{
|
|
"thing": "a thing",
|
|
"anotherThing": "another thing",
|
|
},
|
|
map[string]any{
|
|
"thing": "second thing",
|
|
"anotherThing": "a second other thing",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
// Override values from:
|
|
// --state-values-set top.array[0]=cmdlinething1
|
|
// --state-values-set top.complexArray[1].anotherThing=cmdline
|
|
override := map[string]interface{}{
|
|
"top": map[string]any{
|
|
"array": []any{"cmdlinething1"},
|
|
"complexArray": []any{
|
|
nil,
|
|
map[string]any{
|
|
"anotherThing": "cmdline",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
result := MergeMaps(base, override)
|
|
|
|
// Check array
|
|
resultArray := result["top"].(map[string]any)["array"].([]any)
|
|
expectedArray := []any{"cmdlinething1", "thing2"}
|
|
if !reflect.DeepEqual(resultArray, expectedArray) {
|
|
t.Errorf("Array merge failed:\nExpected: %+v\nGot: %+v", expectedArray, resultArray)
|
|
}
|
|
|
|
// Check complexArray
|
|
resultComplexArray := result["top"].(map[string]any)["complexArray"].([]any)
|
|
if len(resultComplexArray) != 2 {
|
|
t.Fatalf("Expected complexArray length 2, got %d", len(resultComplexArray))
|
|
}
|
|
|
|
elem0 := resultComplexArray[0].(map[string]any)
|
|
if elem0["thing"] != "a thing" || elem0["anotherThing"] != "another thing" {
|
|
t.Errorf("complexArray[0] was modified:\nGot: %+v", elem0)
|
|
}
|
|
|
|
elem1 := resultComplexArray[1].(map[string]any)
|
|
if elem1["thing"] != "second thing" || elem1["anotherThing"] != "cmdline" {
|
|
t.Errorf("complexArray[1] merge failed:\nExpected: {thing: second thing, anotherThing: cmdline}\nGot: %+v", elem1)
|
|
}
|
|
})
|
|
}
|