Dep ensure -update (#1912)

* dep ensure -update

Signed-off-by: Miek Gieben <miek@miek.nl>

* Add new files

Signed-off-by: Miek Gieben <miek@miek.nl>

vendor/github.com/imdario/mergo/issue66_test.go

@@ -20,6 +20,25 @@ func TestPrivateSlice(t *testing.T) {
 	if err := Merge(&p1, p2); err != nil {
 		t.Fatalf("Error during the merge: %v", err)
 	}
+	if len(p1.PublicStrings) != 3 {
+		t.Error("5 elements should be in 'PublicStrings' field")
+	}
+	if len(p1.privateStrings) != 2 {
+		t.Error("2 elements should be in 'privateStrings' field")
+	}
+}
+
+func TestPrivateSliceWithAppendSlice(t *testing.T) {
+	p1 := PrivateSliceTest66{
+		PublicStrings:  []string{"one", "two", "three"},
+		privateStrings: []string{"four", "five"},
+	}
+	p2 := PrivateSliceTest66{
+		PublicStrings: []string{"six", "seven"},
+	}
+	if err := Merge(&p1, p2, WithAppendSlice); err != nil {
+		t.Fatalf("Error during the merge: %v", err)
+	}
 	if len(p1.PublicStrings) != 5 {
 		t.Error("5 elements should be in 'PublicStrings' field")
 	}

vendor/github.com/imdario/mergo/merge.go

@@ -103,7 +103,15 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 				case reflect.Ptr:
 					fallthrough
 				case reflect.Map:
-					if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
+					srcMapElm := srcElement
+					dstMapElm := dstElement
+					if srcMapElm.CanInterface() {
+						srcMapElm = reflect.ValueOf(srcMapElm.Interface())
+						if dstMapElm.IsValid() {
+							dstMapElm = reflect.ValueOf(dstMapElm.Interface())
+						}
+					}
+					if err = deepMerge(dstMapElm, srcMapElm, visited, depth+1, config); err != nil {
 						return
 					}
 				case reflect.Slice:
@@ -116,7 +124,11 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 						dstSlice = reflect.ValueOf(dstElement.Interface())
 					}
 
-					dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
+					if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice {
+						dstSlice = srcSlice
+					} else if config.AppendSlice {
+						dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
+					}
 					dst.SetMapIndex(key, dstSlice)
 				}
 			}
@@ -124,7 +136,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 				continue
 			}
 
-			if srcElement.IsValid() && (overwrite || (!dstElement.IsValid() || isEmptyValue(dst))) {
+			if srcElement.IsValid() && (overwrite || (!dstElement.IsValid() || isEmptyValue(dstElement))) {
 				if dst.IsNil() {
 					dst.Set(reflect.MakeMap(dst.Type()))
 				}
@@ -137,7 +149,7 @@ func deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, co
 		}
 		if !isEmptyValue(src) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice {
 			dst.Set(src)
-		} else {
+		} else if config.AppendSlice {
 			dst.Set(reflect.AppendSlice(dst, src))
 		}
 	case reflect.Ptr:

vendor/github.com/imdario/mergo/mergo.go

@@ -45,7 +45,12 @@ func isEmptyValue(v reflect.Value) bool {
 		return v.Uint() == 0
 	case reflect.Float32, reflect.Float64:
 		return v.Float() == 0
-	case reflect.Interface, reflect.Ptr, reflect.Func:
+	case reflect.Interface, reflect.Ptr:
+		if v.IsNil() {
+			return true
+		}
+		return isEmptyValue(v.Elem())
+	case reflect.Func:
 		return v.IsNil()
 	case reflect.Invalid:
 		return true

vendor/github.com/imdario/mergo/mergo_test.go

@@ -6,11 +6,12 @@
 package mergo
 
 import (
-	"gopkg.in/yaml.v2"
 	"io/ioutil"
 	"reflect"
 	"testing"
 	"time"
+
+	"gopkg.in/yaml.v2"
 )
 
 type simpleTest struct {
@@ -225,13 +226,13 @@ func TestPointerStructNil(t *testing.T) {
 	}
 }
 
-func testSlice(t *testing.T, a []int, b []int) {
+func testSlice(t *testing.T, a []int, b []int, e []int, opts ...func(*Config)) {
+	t.Helper()
 	bc := b
-	e := append(a, b...)
 
 	sa := sliceTest{a}
 	sb := sliceTest{b}
-	if err := Merge(&sa, sb); err != nil {
+	if err := Merge(&sa, sb, opts...); err != nil {
 		t.FailNow()
 	}
 	if !reflect.DeepEqual(sb.S, bc) {
@@ -243,14 +244,14 @@ func testSlice(t *testing.T, a []int, b []int) {
 
 	ma := map[string][]int{"S": a}
 	mb := map[string][]int{"S": b}
-	if err := Merge(&ma, mb); err != nil {
+	if err := Merge(&ma, mb, opts...); err != nil {
 		t.FailNow()
 	}
 	if !reflect.DeepEqual(mb["S"], bc) {
-		t.Fatalf("Source slice was modified %d != %d", mb["S"], bc)
+		t.Fatalf("map value: Source slice was modified %d != %d", mb["S"], bc)
 	}
 	if !reflect.DeepEqual(ma["S"], e) {
-		t.Fatalf("b not merged in a proper way %d != %d", ma["S"], e)
+		t.Fatalf("map value: b not merged in a proper way %d != %d", ma["S"], e)
 	}
 
 	if a == nil {
@@ -261,10 +262,10 @@ func testSlice(t *testing.T, a []int, b []int) {
 			t.FailNow()
 		}
 		if !reflect.DeepEqual(mb["S"], bc) {
-			t.Fatalf("Source slice was modified %d != %d", mb["S"], bc)
+			t.Fatalf("missing dst key: Source slice was modified %d != %d", mb["S"], bc)
 		}
 		if !reflect.DeepEqual(ma["S"], e) {
-			t.Fatalf("b not merged in a proper way %d != %d", ma["S"], e)
+			t.Fatalf("missing dst key: b not merged in a proper way %d != %d", ma["S"], e)
 		}
 	}
 
@@ -276,20 +277,25 @@ func testSlice(t *testing.T, a []int, b []int) {
 			t.FailNow()
 		}
 		if !reflect.DeepEqual(mb["S"], bc) {
-			t.Fatalf("Source slice was modified %d != %d", mb["S"], bc)
+			t.Fatalf("missing src key: Source slice was modified %d != %d", mb["S"], bc)
 		}
 		if !reflect.DeepEqual(ma["S"], e) {
-			t.Fatalf("b not merged in a proper way %d != %d", ma["S"], e)
+			t.Fatalf("missing src key: b not merged in a proper way %d != %d", ma["S"], e)
 		}
 	}
 }
 
 func TestSlice(t *testing.T) {
-	testSlice(t, nil, []int{1, 2, 3})
-	testSlice(t, []int{}, []int{1, 2, 3})
-	testSlice(t, []int{1}, []int{2, 3})
-	testSlice(t, []int{1}, []int{})
-	testSlice(t, []int{1}, nil)
+	testSlice(t, nil, []int{1, 2, 3}, []int{1, 2, 3})
+	testSlice(t, []int{}, []int{1, 2, 3}, []int{1, 2, 3})
+	testSlice(t, []int{1}, []int{2, 3}, []int{1})
+	testSlice(t, []int{1}, []int{}, []int{1})
+	testSlice(t, []int{1}, nil, []int{1})
+	testSlice(t, nil, []int{1, 2, 3}, []int{1, 2, 3}, WithAppendSlice)
+	testSlice(t, []int{}, []int{1, 2, 3}, []int{1, 2, 3}, WithAppendSlice)
+	testSlice(t, []int{1}, []int{2, 3}, []int{1, 2, 3}, WithAppendSlice)
+	testSlice(t, []int{1}, []int{}, []int{1}, WithAppendSlice)
+	testSlice(t, []int{1}, nil, []int{1}, WithAppendSlice)
 }
 
 func TestEmptyMaps(t *testing.T) {

vendor/github.com/imdario/mergo/pr80_test.go

@@ -0,0 +1,18 @@
+package mergo
+
+import (
+	"testing"
+)
+
+type mapInterface map[string]interface{}
+
+func TestMergeMapsEmptyString(t *testing.T) {
+	a := mapInterface{"s": ""}
+	b := mapInterface{"s": "foo"}
+	if err := Merge(&a, b); err != nil {
+		t.Fatal(err)
+	}
+	if a["s"] != "foo" {
+		t.Fatalf("b not merged in properly: a.s.Value(%s) != expected(%s)", a["s"], "foo")
+	}
+}

vendor/github.com/imdario/mergo/pr81_test.go

@@ -0,0 +1,42 @@
+package mergo
+
+import (
+	"testing"
+)
+
+func TestMapInterfaceWithMultipleLayer(t *testing.T) {
+	m1 := map[string]interface{}{
+		"k1": map[string]interface{}{
+			"k1.1": "v1",
+		},
+	}
+
+	m2 := map[string]interface{}{
+		"k1": map[string]interface{}{
+			"k1.1": "v2",
+			"k1.2": "v3",
+		},
+	}
+
+	if err := Map(&m1, m2, WithOverride); err != nil {
+		t.Fatalf("Error merging: %v", err)
+	}
+
+	// Check overwrite of sub map works
+	expected := "v2"
+	actual := m1["k1"].(map[string]interface{})["k1.1"].(string)
+	if actual != expected {
+		t.Fatalf("Expected %v but got %v",
+			expected,
+			actual)
+	}
+
+	// Check new key is merged
+	expected = "v3"
+	actual = m1["k1"].(map[string]interface{})["k1.2"].(string)
+	if actual != expected {
+		t.Fatalf("Expected %v but got %v",
+			expected,
+			actual)
+	}
+}